diff --git a/.azure-pipelines/guardian/SDL/.gdnsuppress b/.azure-pipelines/guardian/SDL/.gdnsuppress
new file mode 100644
index 000000000..2d1eca140
--- /dev/null
+++ b/.azure-pipelines/guardian/SDL/.gdnsuppress
@@ -0,0 +1,105 @@
+{
+  "hydrated": false,
+  "properties": {
+    "helpUri": "https://eng.ms/docs/microsoft-security/security/azure-security/cloudai-security-fundamentals-engineering/security-integration/guardian-wiki/microsoft-guardian/general/suppressions",
+    "hydrationStatus": "This file does not contain identifying data. It is safe to check into your repo. To hydrate this file with identifying data, run `guardian hydrate --help` and follow the guidance."
+  },
+  "version": "1.0.0",
+  "suppressionSets": {
+    "default": {
+      "name": "default",
+      "createdDate": "2024-02-06 21:00:02Z",
+      "lastUpdatedDate": "2024-02-06 21:00:02Z"
+    }
+  },
+  "results": {
+    "bffa73d7410f5963f2538f06124ac5524c076da77867a0a19ccf60e508062dff": {
+      "signature": "bffa73d7410f5963f2538f06124ac5524c076da77867a0a19ccf60e508062dff",
+      "alternativeSignatures": [],
+      "memberOf": [
+        "default"
+      ],
+      "createdDate": "2024-02-06 21:00:02Z"
+    },
+    "964642e3cd0f022d5b63f5d3c467d034df4b1664e58dd132b6cd54c98bdae6a1": {
+      "signature": "964642e3cd0f022d5b63f5d3c467d034df4b1664e58dd132b6cd54c98bdae6a1",
+      "alternativeSignatures": [
+        "f2d5560538c833834ca11e62fa6509618ab5454e1e71faf2847cb6fd07f4c4e0"
+      ],
+      "memberOf": [
+        "default"
+      ],
+      "createdDate": "2024-02-06 21:00:02Z"
+    },
+    "5b0f97262e176cd67207fd63a2c74b9984829286e9229d10efc32d6b73130e37": {
+      "signature": "5b0f97262e176cd67207fd63a2c74b9984829286e9229d10efc32d6b73130e37",
+      "alternativeSignatures": [
+        "29a18985690880b8caeebc339c7d2afd107510838cdc6561c1f5493478712581"
+      ],
+      "memberOf": [
+        "default"
+      ],
+      "createdDate": "2024-02-06 21:00:02Z"
+    },
+    "636fe8a4848f24231e94dc13a238022f90a2894cd47a483e351e467eeb98de52": {
+      "signature": "636fe8a4848f24231e94dc13a238022f90a2894cd47a483e351e467eeb98de52",
+      "alternativeSignatures": [
+        "e20632aa7941af4239fd857f802e05582c841fb9ae84e17c71ca6c7fc713246b"
+      ],
+      "memberOf": [
+        "default"
+      ],
+      "createdDate": "2024-02-06 21:00:02Z"
+    },
+    "67ae7118600b0793ec3f0a58a753888e13ce4badcc15575614ee6aa622e5009c": {
+      "signature": "67ae7118600b0793ec3f0a58a753888e13ce4badcc15575614ee6aa622e5009c",
+      "alternativeSignatures": [
+        "d1e68c2c7d9815f47331dd34c31db2634804b45b078a53d00843082747155ac9"
+      ],
+      "memberOf": [
+        "default"
+      ],
+      "createdDate": "2024-02-06 21:00:02Z"
+    },
+    "9b7d0de03b9e0e0b2711e31df7c804528c357bf5aa2d689fb5a5f42750e84077": {
+      "signature": "9b7d0de03b9e0e0b2711e31df7c804528c357bf5aa2d689fb5a5f42750e84077",
+      "alternativeSignatures": [
+        "e42bf5a49be2b1b815d1fde98ebf9d463fd2e70be1e8ca661f1210ce5b0c4953"
+      ],
+      "memberOf": [
+        "default"
+      ],
+      "createdDate": "2024-02-06 21:00:02Z"
+    },
+    "06ecbceae8bfd10acf8c35f21af3926d172c7930f24a204cc58b61efc6c4c770": {
+      "signature": "06ecbceae8bfd10acf8c35f21af3926d172c7930f24a204cc58b61efc6c4c770",
+      "alternativeSignatures": [
+        "035d6eb1444a809987923a39793fbb1ab9e4462405f38f94bc425c579705a9f2"
+      ],
+      "memberOf": [
+        "default"
+      ],
+      "createdDate": "2024-02-06 21:00:02Z"
+    },
+    "c103671af429c32de81f2dc2e7a92999de88a517d916a8f75c8e37448bb2efe9": {
+      "signature": "c103671af429c32de81f2dc2e7a92999de88a517d916a8f75c8e37448bb2efe9",
+      "alternativeSignatures": [
+        "3f904a503c12b62c2922900a2e689632e06272a815448939b1fdd435bcf74388"
+      ],
+      "memberOf": [
+        "default"
+      ],
+      "createdDate": "2024-02-06 21:00:02Z"
+    },
+    "d1196285a4e64cf6f0f7f22a29bf5b33b540137da1a89ed2af0c880d2a8c1d64": {
+      "signature": "d1196285a4e64cf6f0f7f22a29bf5b33b540137da1a89ed2af0c880d2a8c1d64",
+      "alternativeSignatures": [
+        "1c24094ca9e68a76a81c747853860e46fd139c9f47f0fdbad9133538e7d064b2"
+      ],
+      "memberOf": [
+        "default"
+      ],
+      "createdDate": "2024-02-06 21:00:02Z"
+    }
+  }
+}
diff --git a/.azure-pipelines/publish.yml b/.azure-pipelines/publish.yml
new file mode 100644
index 000000000..0b8c37402
--- /dev/null
+++ b/.azure-pipelines/publish.yml
@@ -0,0 +1,82 @@
+pr: none
+
+trigger:
+  tags:
+    include:
+    - '*'
+
+resources:
+  repositories:
+  - repository: 1esPipelines
+    type: git
+    name: 1ESPipelineTemplates/1ESPipelineTemplates
+    ref: refs/tags/release
+
+extends:
+  template: v1/1ES.Official.PipelineTemplate.yml@1esPipelines
+  parameters:
+    pool:
+      name: DevDivPlaywrightAzurePipelinesUbuntu2204
+      os: linux
+    sdl:
+      sourceAnalysisPool:
+        name: DevDivPlaywrightAzurePipelinesWindows2022
+        # The image must be windows-based due to restrictions of the SDL tools. See: https://aka.ms/AAo6v8e
+        # In the case of a windows build, this can be the same as the above pool image.
+        os: windows
+      suppression:
+        suppressionFile: $(Build.SourcesDirectory)\.azure-pipelines\guardian\SDL\.gdnsuppress
+    stages:
+    - stage: Stage
+      jobs:
+      - job: Build
+        templateContext:
+          outputs:
+          - output: pipelineArtifact
+            path: $(Build.ArtifactStagingDirectory)/esrp-build
+            artifact: esrp-build
+        steps:
+        - task: UsePythonVersion@0
+          inputs:
+            versionSpec: '3.9'
+          displayName: 'Use Python'
+        - script: |
+            python -m pip install --upgrade pip
+            pip install -r local-requirements.txt
+            pip install -r requirements.txt
+            pip install -e .
+            for wheel in $(python setup.py --list-wheels); do
+              PLAYWRIGHT_TARGET_WHEEL=$wheel python -m build --wheel --outdir $(Build.ArtifactStagingDirectory)/esrp-build
+            done
+          displayName: 'Install & Build'
+      - job: Publish
+        dependsOn: Build
+        templateContext:
+          type: releaseJob
+          isProduction: true
+          inputs:
+          - input: pipelineArtifact
+            artifactName: esrp-build
+            targetPath: $(Build.ArtifactStagingDirectory)/esrp-build
+        steps:
+          - checkout: none
+          - task: EsrpRelease@11
+            inputs:
+              connectedservicename: 'Playwright-ESRP-PME'
+              usemanagedidentity: true
+              keyvaultname: 'playwright-esrp-pme'
+              signcertname: 'ESRP-Release-Sign'
+              clientid: '13434a40-7de4-4c23-81a3-d843dc81c2c5'
+              intent: 'PackageDistribution'
+              contenttype: 'PyPi'
+              # Keeping it commented out as a workaround for:
+              # https://portal.microsofticm.com/imp/v3/incidents/incident/499972482/summary
+              # contentsource: 'folder'
+              folderlocation: '$(Build.ArtifactStagingDirectory)/esrp-build'
+              waitforreleasecompletion: true
+              owners: 'yurys@microsoft.com'
+              approvers: 'yurys@microsoft.com'
+              serviceendpointurl: 'https://api.esrp.microsoft.com'
+              mainpublisher: 'Playwright'
+              domaintenantid: '975f013f-7f24-47e8-a7d3-abc4752bf346'
+            displayName: 'ESRP Release to PIP'
diff --git a/.claude/skills/playwright-roll/SKILL.md b/.claude/skills/playwright-roll/SKILL.md
new file mode 100644
index 000000000..9a6adbd03
--- /dev/null
+++ b/.claude/skills/playwright-roll/SKILL.md
@@ -0,0 +1,285 @@
+---
+name: playwright-roll
+description: Roll Playwright Python to a new driver version. Walks the upstream `docs/src/api/` commit range, ports each public-API change, suppresses the rest in `expected_api_mismatch.txt`, regenerates the typed surface, and adds tests.
+---
+
+# Rolling Playwright Python
+
+The goal of a roll is to move `driver_version` in `setup.py` to a new release, port every public API change introduced upstream during that interval, and suppress the rest, so that `./scripts/update_api.sh` runs clean and the test suite still passes.
+
+The previous human-facing summary lives in `../../../ROLLING.md`. This skill is the operational playbook — read it end to end before starting.
+
+## Mental model
+
+The Python port is hand-written code in `playwright/_impl/`, plus a generator (`scripts/generate_*.py`, `scripts/documentation_provider.py`) that:
+
+1. introspects the Python `_impl` classes via `inspect`,
+2. emits typed wrapper classes into `playwright/{async,sync}_api/_generated.py`, and
+3. diffs the introspected surface against `playwright/driver/package/api.json` (downloaded inside the new driver wheel).
+
+Anything in `api.json` that is missing or differently typed in `_impl/` causes generation to fail. Three resolutions:
+
+- **PORT** — the new API is intended for Python (no `langs.only` filter, or `langs.only` includes `"python"`). Implement it in `_impl/`.
+- **MISMATCH** — the API genuinely exists for Python but is shaped differently (a callback signature uses unions, a kwarg uses a legacy name, etc.) and there's a justified reason to keep the divergence. Add a precise line to `scripts/expected_api_mismatch.txt` with a comment explaining *why*.
+- **N/A** — the commit only touches docs, has `* langs: js` (or any other filter that excludes Python), is server-side, Electron-only, or was reverted later in the same release. No action.
+
+The upstream documentation source of truth is `docs/src/api/*.md` in the playwright repo. Every `## method:` / `## property:` / `## event:` / `### option:` / `### param:` block has an optional `* langs: js` (or `js, python`, etc.) filter. The Python doclint resolves these into `langs` fields on each member of `api.json`. **An empty `langs: {}` means "all languages including Python" — *implement it*, don't suppress it.**
+
+> **The mistake the 1.59 roll made twice over:** classifying things as "internal tooling, N/A for Python" based on the *name* of the API (Screencast, Debugger, pickLocator, clearConsoleMessages, artifactsDir, …). Almost all of those had empty `langs: {}` in `api.json` and were real Python APIs. Sounding tooling-y is not a `langs` filter. **The `langs` field on the member in `api.json` is the only authoritative signal.** When in doubt, dump it (see "Verifying classifications" below).
+
+## Pre-flight
+
+You will need two checkouts in the parent directory:
+- `~/code/playwright-python` — this repo.
+- `~/code/playwright` — the upstream playwright monorepo (used read-only for diffing).
+
+Bring upstream up to date and ensure release branches/tags are present:
+
+```sh
+git -C ~/code/playwright fetch --tags
+git -C ~/code/playwright fetch origin 'release-*:release-*'
+```
+
+There is sometimes no `vX.Y.0` tag for the latest release (the bots cut release branches first and tag later). Anchor on commits, not tags — see "Identify the commit range" below.
+
+## Process
+
+### 1. Set up the env
+
+`CONTRIBUTING.md` covers this. Notes from past rolls:
+
+- The repo says Python 3.9 is required, but 3.9+ works. If `python3.9` isn't available, use `python3` (3.12 is fine).
+- If `python3-venv` is missing system-wide, use `uv venv env` instead, then `uv pip install --python env/bin/python --upgrade pip`. Don't try to `apt install` — sudo is denied in the harness.
+- Always activate the venv before any `pip`, `pytest`, `mypy`, or `pre-commit` invocation.
+
+### 2. Bump the driver and download it
+
+```sh
+# Edit setup.py
+driver_version = "<new>"     # e.g. "1.59.1"
+
+source env/bin/activate
+python -m build --wheel       # downloads the new driver from cdn.playwright.dev
+playwright install chromium   # NOT --with-deps; sudo is denied
+```
+
+The wheel build prints `Fetching https://cdn.playwright.dev/builds/driver/playwright-<new>-linux.zip` and unpacks the driver under `playwright/driver/package/`. From this point, `playwright/driver/package/api.json` reflects the new release.
+
+### 3. Identify the commit range
+
+The diff range is "every commit on the new release branch since the previous release was cut". Anchor commits:
+
+- **Previous release end**: the `chore: bump version to vX.Y.0-next` commit on `main`. That commit is the first commit *after* the previous release (X.Y-1) was cut. Use its parent (`<sha>~1`) as the lower bound.
+  ```sh
+  git -C ~/code/playwright log --all --grep="bump version to v" --oneline | head
+  ```
+- **New release end**: the tip of `release-<new>` (or the matching tag if it exists).
+
+Save the commit list, oldest first, scoped to `docs/src/api/`:
+
+```sh
+git -C ~/code/playwright log <prev-anchor>~1..release-<new> --oneline --reverse -- docs/src/api > /tmp/roll-<new>-commits.md
+```
+
+A normal roll yields 50–100 commits. If you see 0 or thousands, the range is wrong.
+
+Format the file as a markdown checklist and add the standard preamble (status legend, where to look up `api.json` etc.) — see the file from the 1.58→1.59 roll for the template.
+
+### 4. Walk the commit list
+
+For each commit, in chronological order:
+
+```sh
+git -C ~/code/playwright show <sha> -- docs/src/api/
+```
+
+Look for:
+- `## (async )?method:` / `## property:` / `## event:` additions or removals;
+- `* langs: ...` lines on those blocks;
+- `### param:` / `### option:` additions or removals;
+- new `class-X.md` files (whole new classes — usually `langs: js`);
+- type changes in `- returns:` lines.
+
+Classify and act.
+
+#### Verifying classifications (do this before suppressing anything)
+
+Before tagging anything as MISMATCH or N/A based on appearance, dump the actual `langs` from `api.json`:
+
+```python
+import json
+data = json.load(open("playwright/driver/package/api.json"))
+classes = {c["name"]: c for c in data}
+for cls_name in ["Page", "BrowserContext", "Screencast", "Debugger"]:
+    cls = classes.get(cls_name)
+    if not cls:
+        continue
+    print(f"\n{cls_name}: cls_langs={cls.get('langs', {})}")
+    for m in cls["members"]:
+        print(f"  {m['name']} kind={m.get('kind')} langs={m.get('langs', {})}")
+```
+
+For options/params nested inside an `Object`-typed arg, walk one level deeper:
+
+```python
+for a in member.get("args", []):
+    if a["name"] == "options":
+        for prop in a.get("type", {}).get("properties", []):
+            print(prop["name"], prop.get("langs", {}))
+```
+
+A few rules of thumb that catch most "actually a PORT" cases:
+- If the *containing class* has empty `langs: {}` and the *member* has empty `langs: {}`, it's for Python — implement it.
+- If the member is empty but a single *option* has `langs: js`, the method is for Python and you only skip that option (e.g. `Screencast.start.size` is `langs: js` while `Screencast.start` itself isn't).
+- If you're about to add three or more `Method not implemented:` entries for the same class, stop — you almost certainly need to implement the class.
+
+#### PORT
+
+Implement the change in `playwright/_impl/<module>.py`. Use the upstream JS implementation as a reference: `~/code/playwright/packages/playwright-core/src/client/<module>.ts`. Translate idioms:
+
+| Upstream JS | Python |
+|---|---|
+| `async foo(): Promise<X>` | `async def foo(self) -> X:` |
+| `foo(): X` (sync getter, no args, no body) | `@property def foo(self) -> X:` (the doc generator treats argument-less sync getters as properties — see `documentation_provider.py:133`. If you make it a method instead, you'll get a "Method vs property mismatch" error.) |
+| `await this._channel.foo({ a, b })` | `await self._channel.send("foo", None, locals_to_params(locals()))` |
+| `(await this._channel.foo()).value` | `await self._channel.send("foo", None)` (Python's `send()` auto-unwraps single-key responses; only call `send_return_as_dict` when the protocol returns multiple keys.) |
+| `(await this._channel.foo()).artifact` (multi-key, may be empty) | `result = await self._channel.send_return_as_dict("foo", None); (result or {}).get("artifact")` — `send_return_as_dict` returns **`None`** (not `{}`) when the protocol response carries no fields. |
+| `try { ... } catch (e) { if (isTargetClosedError(e)) return; throw e; }` | `try: ...; except Exception as e: if is_target_closed_error(e): return; raise` (import from `playwright._impl._errors`) |
+| Inline `[Object]` return like `{endpoint: string}` | A `TypedDict` in `playwright/_impl/_api_structures.py` — *not* `Dict[str, str]`. The doc generator serializes TypedDicts as `{field: type, ...}` via `get_type_hints` and that matches the inline-object form exactly. See `RemoteAddr`, `BrowserBindResult`, `DebuggerPausedDetails`. |
+| `binary` event/return field | The Python channel layer hands you a base64 string. Decode with `base64.b64decode(value)` before exposing as `bytes`. See `Screencast._dispatch_frame`. |
+
+When implementing a new ChannelOwner subclass (one constructed by the protocol with `(parent, type, guid, initializer)`):
+1. Register it in `playwright/_impl/_object_factory.py:create_remote_object` — otherwise the guid resolves to `DummyObject` and downstream code breaks mysteriously.
+2. Import it and add it to `generated_types` in `scripts/generate_api.py`, plus add a `XxxImpl` import in the `header` string.
+
+When implementing a non-ChannelOwner wrapper class (a plain class that holds a Page/Context reference, like `Screencast`, `Clock`):
+- Set `self._loop = parent._loop` and `self._dispatcher_fiber = parent._dispatcher_fiber` in `__init__`. The generated `AsyncBase`/`SyncBase` wrappers read these; missing them gives `AttributeError: 'X' object has no attribute '_loop'` at first use.
+
+When adding a new TypedDict in `_api_structures.py`:
+- Add it to the `from playwright._impl._api_structures import …` line in `scripts/generate_api.py` so the generator can resolve it as a forward reference in type hints.
+- Re-export it from both `playwright/async_api/__init__.py` and `playwright/sync_api/__init__.py`: assignment line plus an entry in `__all__`. Same pattern as `ViewportSize`, `RemoteAddr`.
+
+If the new API was previously suppressed in `expected_api_mismatch.txt`, **remove that line** when implementing it.
+
+If a doc rename involves a *positional* parameter (no default, before any `*`), users almost certainly call it positionally — you can rename freely. The 1.59 `BrowserType.connect.wsEndpoint` → `endpoint` is the canonical example. Don't suppress this kind of rename; just rename in `_impl/`. **Important corollary:** when docs rename a param, the wire-protocol field usually also changed in `packages/protocol/src/protocol.yml` and the server-side dispatcher in `packages/playwright-core/src/server/dispatchers/*Dispatcher.ts`. If so, you must also update the channel-send dict key (e.g. `{"wsEndpoint": …}` → `{"endpoint": …}`). A "Parameter not documented" suppression for a renamed param is a code smell hiding a wire-protocol bug.
+
+#### MISMATCH
+
+A MISMATCH is a *justified, durable* divergence between the docs and the Python surface. Use it sparingly — most apparent mismatches turn out to be PORTs you skipped. Legitimate examples in the current `expected_api_mismatch.txt`:
+
+- Hidden internal kwargs (`Browser.new_context(default_browser_type=)`).
+- Callback signatures where Python explicitly unions one-arg and two-arg variants but the docs document only the canonical form (`Page.route(handler=)`, `WebSocketRoute.on_close(handler=)`).
+
+Add a precise line to `scripts/expected_api_mismatch.txt` with a `# comment` group header explaining *why* the divergence is intentional. The exact wording comes from the generator's error message. Examples:
+
+```
+# One vs two arguments in the callback, Python explicitly unions.
+Parameter type mismatch in Page.route(handler=): documented as Callable[[Route, Request], Union[Any, Any]], code has Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
+```
+
+The generator removes lines from `expected_api_mismatch.txt` that no longer match an error. If you see "No longer there: …" in the script's stderr, delete that line.
+
+**Do not suppress** these — they're PORTs in disguise:
+
+- "Internal tooling" classes/methods whose `langs` field is empty (`Screencast.*`, `Debugger.*`, `Page.pick_locator`, `BrowserContext.debugger`, `Browser.bind/unbind`, `Page.{clear,console}_*`). The 1.59 roll suppressed all of these initially, then had to walk every one back. Verify `langs` first.
+- A renamed positional parameter (`Parameter not documented: X.y(old_name=)` + `Parameter not implemented: X.y(new_name=)`). Just rename in `_impl/` and update the channel-send dict key.
+- A `Parameter type mismatch in X.y(return=): documented as {field: T}, code has Dict[str, T]`. Use a TypedDict.
+
+#### N/A
+
+Common N/A flavors:
+- Whole new class with `langs: js` (Disposable, Inspector/Screencast, Debugger, Overlay).
+- Members with `langs: js` (most "tooling" / MCP / agentic features).
+- Doc-only edits (typo fixes, "Improve `not` property sections", etc.).
+- Reverts that cancel an earlier add in the same range (always check the rest of the range before porting something that gets reverted).
+- Java/C# `langs:` blocks.
+- Electron-only changes (`docs/src/api/class-electron.md`).
+
+Tick the box in `/tmp/roll-<new>-commits.md` with one line: `[x] <sha> <subject> — <classification>: <one-liner>`.
+
+### 5. Regenerate
+
+```sh
+./scripts/update_api.sh
+```
+
+The script does, in order:
+1. `git checkout HEAD -- playwright/{async,sync}_api/_generated.py` (resets to last committed),
+2. runs `scripts/generate_{sync,async}_api.py` which dumps to `.x` then renames into place,
+3. invokes `pre-commit run --files` on the generated files.
+
+Failure modes and fixes:
+
+| Symptom | Cause | Fix |
+|---|---|---|
+| `Method not implemented: X.y` | `api.json` documents `X.y`, no Python impl exists. | PORT it, or add a MISMATCH line. |
+| `Parameter not implemented: X.y(z=)` | New parameter on existing method. | Add the kwarg in `_impl/`, or MISMATCH. |
+| `Method vs property mismatch: X.y` | You implemented as a method but the doc treats it as a property (sync, no args, has return type). | Add `@property` in `_impl/`. |
+| `Method not documented: X.y` | Python has it but `api.json` doesn't. | The upstream removed the API; remove from `_impl/` and from `_generated.py` callers. |
+| `Parameter type mismatch in X.y(z=): documented as ..., code has ...` | Type signature doesn't line up. | Match the type in `_impl/`, or MISMATCH it for known historical divergences. |
+| `pyright … reportInconsistentOverload` (single-event class) | A class gained its first event in `api.json`, so the generator emits one `Literal[…]` overload + impl, which pyright wants ≥2 of. | The generator already handles this — `documentation_provider.print_events` emits a second `@typing.overload` with `event: str` plus a generic impl. If you regress this, see how 1.59 handled `CDPSession` getting a `close` event. |
+| `pre-commit` keeps reformatting `_generated.py` on each run | First run after regen always reformats once; rerun until idle. | `pre-commit run --all-files` to settle. |
+| `Parameter not documented: X.y(z=)` | Python has a kwarg the docs don't mention (e.g. legacy name from a doc rename). | If the param is positional with no default, just rename it in `_impl/`. Check `protocol.yml` and the server dispatcher — if the wire field renamed too, also update the channel-send dict key. Only MISMATCH for genuinely hidden internal kwargs (`default_browser_type`). |
+| `KeyError: 'templates'` deep in `inner_serialize_doc_type` | A `Promise<X>\|X` union upstream collapsed to a bare `Promise` with no templates in `api.json`. | `documentation_provider.inner_serialize_doc_type` should treat that as `Any` (`if "templates" not in type: return "Any"`). |
+| `"void" is not defined (reportUndefinedVariable)` in generated event handlers | `api.json` has a `void`-typed event payload that the serializer left as the literal string `"void"`. | `documentation_provider.inner_serialize_doc_type` should map `"void"` to `"None"` alongside `"null"`. |
+| `AttributeError: 'X' object has no attribute '_loop'` (or `_dispatcher_fiber`) at first use of a new wrapper class | The non-ChannelOwner wrapper isn't initializing the fields the generated `AsyncBase`/`SyncBase` reads. | In the wrapper's `__init__`, set `self._loop = parent._loop` and `self._dispatcher_fiber = parent._dispatcher_fiber`. |
+| `'NoneType' object has no attribute 'get'` after `send_return_as_dict` | Method's protocol response carries no fields and `send_return_as_dict` returned `None`. | `(result or {}).get(...)`. |
+| Frame/buffer payload arrives as a `str` instead of `bytes` | Protocol `binary` fields cross the wire as base64. | `base64.b64decode(value)` in the impl before exposing. |
+
+After the script settles, run `pre-commit run --all-files` once more to confirm everything is idle.
+
+### 6. Add tests
+
+For each PORT, add one async test and a matching sync test. Conventions:
+
+- Tests go in the existing topic file (`test_page_network_request.py`, `test_browsercontext.py`, `test_dialog.py`, …) — don't create new files unless there's no obvious home.
+- Use `from playwright.async_api import …`, **not** `from playwright._impl._page import Page` (the impl class doesn't have the public wrappers like `expect_console_message`).
+- For event-info objects, `await message_info.value` (it's an `async` property).
+- Don't write tests that hang the page (e.g. `page.evaluate(... fetch slow ...)` followed by `page.close()` from a fixture) — the request task gets a `TargetClosedError`. Use `page.on("event", handler)` to capture state at event time instead.
+- `playwright install chromium` (no `--with-deps`) is sufficient for the test suite under sandbox.
+
+### 7. Update existing high-touch artifacts
+
+- `setup.py`: already done in step 2.
+- `README.md`: gets the chromium/firefox/webkit version table updated automatically by `scripts/update_versions.py` (called from `update_api.sh`). Don't edit by hand.
+- The "Backport changes" tracking issue on GitHub (filed by `microsoft-playwright-automation`) is the *intent* tracker, but it's frequently out of sync with what's actually been ported. Treat it as a starting point, not the source of truth — the `docs/src/api/` commit walk is authoritative.
+
+### 8. Final verification
+
+```sh
+pre-commit run --all-files
+mypy playwright                 # 2 pre-existing errors in _json_pipe.py and _artifact.py are unrelated
+pytest --browser chromium tests/async/<files-you-touched> tests/sync/<files-you-touched>
+```
+
+Then a smoke regression on a few neighboring suites (`tests/async/test_browser*.py`, `test_cdp_session.py`, `test_tracing.py`, `test_dialog.py`, `test_page_*.py`) to make sure nothing inherent to the port shifted.
+
+## Reference: `expected_api_mismatch.txt` line forms
+
+Exact strings the generator emits (and that this file must contain to suppress):
+
+```
+Method not implemented: <Class>.<snake_method>
+Parameter not implemented: <Class>.<snake_method>(<snake_param>=)
+Parameter not documented: <Class>.<snake_method>(<snake_param>=)
+Method vs property mismatch: <Class>.<snake_method>
+Method not documented: <Class>.<snake_method>
+Parameter type mismatch in <Class>.<snake_method>(<arg>=): documented as <T1>, code has <T2>
+```
+
+Class names use the upstream PascalCase (`BrowserContext`, `BrowserType`); method/param names are converted to `snake_case` matching the Python surface.
+
+## Tips & gotchas
+
+- **`langs.only` is your filter — and the only filter.** Don't classify by name (`Screencast`, `Debugger`, `pickLocator`) or by intuition ("looks like internal tooling"). Always check `langs` in `api.json`. The 1.59 roll cost two extra audit passes by trusting names over `langs`.
+- **Audit your own classifications a second time.** After the first walk through the commit range, before opening the PR, re-read every line in `expected_api_mismatch.txt` you added during this roll and ask "is this divergence justified, or did I skip a port?" Run the `langs`-dump snippet on each suspicious entry. The 1.59 roll's first PR had ~20 wrong suppressions; the second pass cut them to 0.
+- **A cluster of suppressions on the same class is a smell.** If you're about to add five `Method not implemented: Foo.*` lines, you're almost certainly looking at a class that needs to be implemented. Implement the whole thing once and the suppressions disappear.
+- **Watch for revert pairs in the same range.** 1.59 added and reverted `Browser.isRemote` (#39613 / #39620) inside the same release. Walking chronologically lets you skip the add when you see the revert later.
+- **Watch for rename-revert pairs.** 1.59 had `Locator.normalize` → `Locator.toCode` (#39648) → `Locator.normalize` (#39754). Final state wins; only port the last.
+- **Doc renames almost always include a wire-protocol rename.** Whenever you see `### param: X.y.oldName` → `### param: X.y.newName` in a doc commit, also `git -C ~/code/playwright show <sha> -- packages/protocol/src/protocol.yml` and the corresponding `*Dispatcher.ts` file. If the wire field changed too, the channel-send dict key in `_impl/` must change. Suppressing the doc-side mismatch is hiding a real bug — the previous Python code is silently sending an unknown field that the new server ignores.
+- **TypedDicts beat `Dict[str, X]` for any structured return.** When the docs describe a return as `[Object]` with named fields (or even `[Object=Foo]`), define a `TypedDict` in `_api_structures.py`, re-export from both public `__init__.py` files, and use it. Zero runtime cost (it's still a `dict`), and the doc generator's type comparator matches by structure via `get_type_hints`.
+- **Positional renames are free.** A param with no default before any `*` separator is positional-or-keyword in Python, but realistic call sites pass it positionally. Renaming such a param doesn't break callers.
+- **The "Backport changes" GitHub issue can be misleading.** In the 1.59 roll its checkboxes were all marked `[x]` with annotations like "✅ IMPLEMENTED", but several of those features had not actually been merged into the Python port. Trust the `docs/src/api/` walk over the issue.
+- **`api.json` may carry doclint quirks.** 1.59 hit two: `Promise<X>|X` collapsed to a bare `Promise` with no `templates`, and `void`-typed events serialized as the literal string `"void"`. Both are upstream artifacts; patch `inner_serialize_doc_type` to handle them rather than fighting the api.json side.
+- **Don't edit `_generated.py` to fix lint or typing.** Fix `_impl/`, `documentation_provider.py`, or `expected_api_mismatch.txt` instead. Hand-editing the generated file is reverted on the next regen.
+- **`/tmp/roll-<new>-commits.md` is a working artifact, not a deliverable.** Don't commit it. The commit message and PR description are where the audit summary belongs.
diff --git a/.dockerignore b/.dockerignore
deleted file mode 100644
index d77391baa..000000000
--- a/.dockerignore
+++ /dev/null
@@ -1 +0,0 @@
-!/dist/playwright*manylinux1*.whl
diff --git a/.gitattributes b/.gitattributes
index 03d42ee97..f234cf677 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,3 +1,2 @@
 # text files must be lf for golden file tests to work
-*.txt eol=lf
-*.json eol=lf
+* text=auto eol=lf
diff --git a/.github/ISSUE_TEMPLATE/bug.yml b/.github/ISSUE_TEMPLATE/bug.yml
new file mode 100644
index 000000000..620ff4109
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug.yml
@@ -0,0 +1,96 @@
+name: Bug Report 🪲
+description: Create a bug report to help us improve
+title: '[Bug]: '
+body:
+  - type: markdown
+    attributes:
+      value: |
+        # Please follow these steps first:
+  - type: markdown
+    attributes:
+      value: |
+        ## Troubleshoot
+        If Playwright is not behaving the way you expect, we'd ask you to look at the [documentation](https://playwright.dev/python/docs/intro) and search the issue tracker for evidence supporting your expectation.
+        Please make reasonable efforts to troubleshoot and rule out issues with your code, the configuration, or any 3rd party libraries you might be using.
+        Playwright offers [several debugging tools](https://playwright.dev/python/docs/debug) that you can use to troubleshoot your issues.
+  - type: markdown
+    attributes:
+      value: |
+        ## Ask for help through appropriate channels
+        If you feel unsure about the cause of the problem, consider asking for help on for example [StackOverflow](https://stackoverflow.com/questions/ask) or our [Discord channel](https://aka.ms/playwright/discord) before posting a bug report. The issue tracker is not a help forum.
+  - type: markdown
+    attributes:
+      value: |
+        ## Make a minimal reproduction
+        To file the report, you will need a GitHub repository with a minimal (but complete) example and simple/clear steps on how to reproduce the bug.
+        The simpler you can make it, the more likely we are to successfully verify and fix the bug.
+  - type: markdown
+    attributes:
+      value: |
+        > [!IMPORTANT]
+        > Bug reports without a minimal reproduction will be rejected.
+
+        ---
+  - type: input
+    id: version
+    attributes:
+      label: Version
+      description: |
+        The version of Playwright you are using.
+        Is it the [latest](https://github.com/microsoft/playwright-python/releases)? Test and see if the bug has already been fixed.
+      placeholder: ex. 1.41.1
+    validations:
+      required: true
+  - type: textarea
+    id: reproduction
+    attributes:
+      label: Steps to reproduce
+      description: Please link to a repository with a minimal reproduction and describe accurately how we can reproduce/verify the bug.
+      value: |
+        Example steps (replace with your own):
+        1. Clone my repo at https://github.com/<myuser>/example
+        2. pip install -r requirements.txt
+        3. python test.py
+        4. You should see the error come up
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: A description of what you expect to happen.
+      placeholder: I expect to see X or Y
+    validations:
+      required: true
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: Actual behavior
+      description: |
+        A clear and concise description of the unexpected behavior.
+        Please include any relevant output here, especially any error messages.
+      placeholder: A bug happened!
+    validations:
+      required: true
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      description: Anything else that might be relevant
+    validations:
+      required: false
+  - type: textarea
+    id: envinfo
+    attributes:
+      label: Environment
+      description: |
+        Please provide information about the environment you are running in.
+      value: |
+        - Operating System: [Ubuntu 22.04]
+        - CPU: [arm64]
+        - Browser: [All, Chromium, Firefox, WebKit]
+        - Python Version: [3.12]
+        - Other info:
+      render: Text
+    validations:
+      required: true
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 000000000..13b5b0a96
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Join our Discord Server
+    url: https://aka.ms/playwright/discord
+    about: Ask questions and discuss with other community members
diff --git a/.github/ISSUE_TEMPLATE/documentation.yml b/.github/ISSUE_TEMPLATE/documentation.yml
new file mode 100644
index 000000000..eaf31b8bd
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/documentation.yml
@@ -0,0 +1,29 @@
+name: Documentation 📖
+description: Submit a request to add or update documentation
+title: '[Docs]: '
+labels: ['Documentation :book:']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ### Thank you for helping us improve our documentation!
+        Please be sure you are looking at [the Next version of the documentation](https://playwright.dev/python/docs/next/intro) before opening an issue here.
+  - type: textarea
+    id: links
+    attributes:
+      label: Page(s)
+      description: |
+        Links to one or more documentation pages that should be modified.
+        If you are reporting an issue with a specific section of a page, try to link directly to the nearest anchor.
+        If you are suggesting that a new page be created, link to the parent of the proposed page.
+    validations:
+      required: true
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: |
+        Describe the change you are requesting.
+        If the issue pertains to a single function or matcher, be sure to specify the entire call signature.
+    validations:
+      required: true
diff --git a/.github/ISSUE_TEMPLATE/feature.yml b/.github/ISSUE_TEMPLATE/feature.yml
new file mode 100644
index 000000000..efec3315c
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature.yml
@@ -0,0 +1,30 @@
+name: Feature Request 🚀
+description: Submit a proposal for a new feature
+title: '[Feature]: '
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ### Thank you for taking the time to suggest a new feature!
+  - type: textarea
+    id: description
+    attributes:
+      label: '🚀 Feature Request'
+      description: A clear and concise description of what the feature is.
+    validations:
+      required: true
+  - type: textarea
+    id: example
+    attributes:
+      label: Example
+      description: Describe how this feature would be used.
+    validations:
+      required: false
+  - type: textarea
+    id: motivation
+    attributes:
+      label: Motivation
+      description: |
+        Outline your motivation for the proposal. How will it make Playwright better?
+    validations:
+      required: true
diff --git a/.github/ISSUE_TEMPLATE/question.yml b/.github/ISSUE_TEMPLATE/question.yml
new file mode 100644
index 000000000..9615afdc8
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/question.yml
@@ -0,0 +1,27 @@
+name: 'Questions / Help 💬'
+description: If you have questions, please check StackOverflow or Discord
+title: '[Please read the message below]'
+labels: [':speech_balloon: Question']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## Questions and Help 💬
+
+        This issue tracker is reserved for bug reports and feature requests.
+
+        For anything else, such as questions or getting help, please see:
+
+        - [The Playwright documentation](https://playwright.dev)
+        - [Our Discord server](https://aka.ms/playwright/discord)
+  - type: checkboxes
+    id: no-post
+    attributes:
+      label: |
+        Please do not submit this issue.
+      description: |
+        > [!IMPORTANT]
+        > This issue will be closed.
+      options:
+        - label: I understand
+          required: true
diff --git a/.github/ISSUE_TEMPLATE/regression.yml b/.github/ISSUE_TEMPLATE/regression.yml
new file mode 100644
index 000000000..35879ad72
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/regression.yml
@@ -0,0 +1,92 @@
+name: Report regression
+description: Functionality that used to work and does not any more
+title: "[Regression]: "
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        # Please follow these steps first:
+  - type: markdown
+    attributes:
+      value: |
+        ## Make a minimal reproduction
+        To file the report, you will need a GitHub repository with a minimal (but complete) example and simple/clear steps on how to reproduce the regression.
+        The simpler you can make it, the more likely we are to successfully verify and fix the regression.
+  - type: markdown
+    attributes:
+      value: |
+        > [!IMPORTANT]
+        > Regression reports without a minimal reproduction will be rejected.
+
+        ---
+  - type: input
+    id: goodVersion
+    attributes:
+      label: Last Good Version
+      description: |
+        Last version of Playwright where the feature was working.
+      placeholder: ex. 1.40.1
+    validations:
+      required: true
+  - type: input
+    id: badVersion
+    attributes:
+      label: First Bad Version
+      description: |
+        First version of Playwright where the feature was broken.
+        Is it the [latest](https://github.com/microsoft/playwright-python/releases)? Test and see if the regression has already been fixed.
+      placeholder: ex. 1.41.1
+    validations:
+      required: true
+  - type: textarea
+    id: reproduction
+    attributes:
+      label: Steps to reproduce
+      description: Please link to a repository with a minimal reproduction and describe accurately how we can reproduce/verify the bug.
+      value: |
+        Example steps (replace with your own):
+        1. Clone my repo at https://github.com/<myuser>/example
+        2. pip -r requirements.txt
+        3. python test.py
+        4. You should see the error come up
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: A description of what you expect to happen.
+      placeholder: I expect to see X or Y
+    validations:
+      required: true
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: Actual behavior
+      description: A clear and concise description of the unexpected behavior.
+      placeholder: A bug happened!
+    validations:
+      required: true
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      description: Anything else that might be relevant
+    validations:
+      required: false
+  - type: textarea
+    id: envinfo
+    attributes:
+      label: Environment
+      description: |
+        Please provide information about the environment you are running in.
+      value: |
+        - Operating System: [Ubuntu 22.04]
+        - CPU: [arm64]
+        - Browser: [All, Chromium, Firefox, WebKit]
+        - Python Version: [3.12]
+        - Other info:
+      render: Text
+    validations:
+      required: true
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 000000000..33c127127
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,14 @@
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      actions:
+        patterns:
+          - "*"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7c8f14b83..9abb66777 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -3,118 +3,184 @@ name: CI
 on:
   push:
     branches:
-      - master
+      - main
       - release-*
   pull_request:
     branches:
-      - master
+      - main
       - release-*
 
+concurrency:
+  # For pull requests, cancel all currently-running jobs for this workflow
+  # https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#concurrency
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
 jobs:
   infra:
     name: Lint
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: microsoft/playwright-github-action@v1
+    - uses: actions/checkout@v6
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v6
       with:
-        python-version: 3.8
-    - name: Install dependencies
+        python-version: "3.10"
+    - name: Install dependencies & browsers
       run: |
         python -m pip install --upgrade pip
         pip install -r local-requirements.txt
+        pip install -r requirements.txt
         pip install -e .
-    - name: Build package
-      run: python setup.py bdist_wheel
-    - name: Install browsers
-      run: python -m playwright install
+        python -m build --wheel
+        python -m playwright install --with-deps
     - name: Lint
-      run: pre-commit run --all-files
-    - name: Test Sync generation script
-      run: bash scripts/verify_api.sh
+      run: pre-commit run --show-diff-on-failure --color=always --all-files
+    - name: Generate APIs
+      run: bash scripts/update_api.sh
+    - name: Verify generated API is up to date
+      run: git diff --exit-code
+
   build:
     name: Build
-    timeout-minutes: 30
+    timeout-minutes: 45
     strategy:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: [3.7, 3.8]
+        python-version: ['3.9', '3.10']
         browser: [chromium, firefox, webkit]
+        exclude:
+        # WebKit on standard macOS-latest (currently macos-15-arm64) is unstable;
+        # upstream pins paid macos-15-xlarge for cross-browser webkit too.
+        - os: macos-latest
+          browser: webkit
         include:
+        - os: macos-15-xlarge
+          python-version: '3.9'
+          browser: webkit
+        - os: macos-15-xlarge
+          python-version: '3.10'
+          browser: webkit
+        - os: windows-latest
+          python-version: '3.11'
+          browser: chromium
+        - os: macos-latest
+          python-version: '3.11'
+          browser: chromium
+        - os: ubuntu-latest
+          python-version: '3.11'
+          browser: chromium
+        - os: windows-latest
+          python-version: '3.12'
+          browser: chromium
+        - os: macos-latest
+          python-version: '3.12'
+          browser: chromium
         - os: ubuntu-latest
-          python-version: 3.9
+          python-version: '3.12'
           browser: chromium
         - os: windows-latest
-          python-version: 3.9
+          python-version: '3.13'
           browser: chromium
         - os: macos-latest
-          python-version: 3.9
+          python-version: '3.13'
           browser: chromium
-        - os: macos-11.0
-          python-version: 3.9
+        - os: ubuntu-latest
+          python-version: '3.13'
           browser: chromium
-        - os: macos-11.0
-          python-version: 3.9
-          browser: firefox
-        - os: macos-11.0
-          python-version: 3.9
-          browser: webkit
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v2
-    - uses: microsoft/playwright-github-action@v1
+    - uses: actions/checkout@v6
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
-    - name: Install dependencies
+    - name: Install dependencies & browsers
       run: |
-        python -m pip install --upgrade pip wheel
+        python -m pip install --upgrade pip
         pip install -r local-requirements.txt
+        pip install -r requirements.txt
         pip install -e .
-    - name: Build package
-      run: python setup.py bdist_wheel
-    - name: Install browsers
-      run: python -m playwright install
+        python -m build --wheel
+        python -m playwright install --with-deps ${{ matrix.browser }}
     - name: Common Tests
-      run: pytest -vv tests/common --browser=${{ matrix.browser }} --timeout 90
+      run: pytest tests/common --browser=${{ matrix.browser }} --timeout 90
+    - name: Test Reference count
+      run: pytest tests/test_reference_count_async.py --browser=${{ matrix.browser }}
+    - name: Test Wheel Installation
+      run: pytest tests/test_installation.py --browser=${{ matrix.browser }}
     - name: Test Sync API
       if: matrix.os != 'ubuntu-latest'
-      run: pytest -vv tests/sync --browser=${{ matrix.browser }} --timeout 90
+      run: pytest tests/sync --browser=${{ matrix.browser }} --timeout 90
     - name: Test Sync API
       if: matrix.os == 'ubuntu-latest'
-      run: xvfb-run pytest -vv tests/sync --browser=${{ matrix.browser }} --timeout 90
+      run: xvfb-run pytest tests/sync --browser=${{ matrix.browser }} --timeout 90
     - name: Test Async API
       if: matrix.os != 'ubuntu-latest'
-      run: pytest -vv tests/async --browser=${{ matrix.browser }} --timeout 90
+      run: pytest tests/async --browser=${{ matrix.browser }} --timeout 90
     - name: Test Async API
       if: matrix.os == 'ubuntu-latest'
-      run: xvfb-run pytest -vv tests/async --browser=${{ matrix.browser }} --timeout 90
+      run: xvfb-run pytest tests/async --browser=${{ matrix.browser }} --timeout 90
 
-  test-package-installations:
-    name: Test package installations
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
+  test-stable:
+    name: Stable
+    timeout-minutes: 45
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        browser-channel: [chrome]
+        include:
+        - os: windows-latest
+          browser-channel: msedge
+        - os: macos-latest
+          browser-channel: msedge
+    runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v2
-    - uses: microsoft/playwright-github-action@v1
-    - name: Set up Node.js
-      uses: actions/setup-node@v1
-      with:
-        node-version: 12.x
+    - uses: actions/checkout@v6
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v6
       with:
-        python-version: 3.8
-    - name: Install dependencies
+        python-version: "3.10"
+    - name: Install dependencies & browsers
       run: |
         python -m pip install --upgrade pip
         pip install -r local-requirements.txt
+        pip install -r requirements.txt
         pip install -e .
-    - name: Build package
-      run: python setup.py bdist_wheel
-    - name: Test package installation
-      run: bash buildbots/test-package-installations.sh
+        python -m build --wheel
+        python -m playwright install ${{ matrix.browser-channel }} --with-deps
+    - name: Common Tests
+      run: pytest tests/common --browser=chromium --browser-channel=${{ matrix.browser-channel }} --timeout 90
+    - name: Test Sync API
+      if: matrix.os != 'ubuntu-latest'
+      run: pytest tests/sync --browser=chromium --browser-channel=${{ matrix.browser-channel }} --timeout 90
+    - name: Test Sync API
+      if: matrix.os == 'ubuntu-latest'
+      run: xvfb-run pytest tests/sync --browser=chromium --browser-channel=${{ matrix.browser-channel }} --timeout 90
+    - name: Test Async API
+      if: matrix.os != 'ubuntu-latest'
+      run: pytest tests/async --browser=chromium --browser-channel=${{ matrix.browser-channel }} --timeout 90
+    - name: Test Async API
+      if: matrix.os == 'ubuntu-latest'
+      run: xvfb-run pytest tests/async --browser=chromium --browser-channel=${{ matrix.browser-channel }} --timeout 90
+
+  test_examples:
+    name: Examples
+    runs-on: ubuntu-22.04
+    defaults:
+      run:
+        working-directory: examples/todomvc/
+    steps:
+    - uses: actions/checkout@v6
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: '3.10'
+    - name: Install dependencies & browsers
+      run: |
+        pip install -r requirements.txt
+        python -m playwright install --with-deps chromium
+    - name: Common Tests
+      run: pytest
diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml
deleted file mode 100644
index 2e90d2599..000000000
--- a/.github/workflows/deploy-docs.yml
+++ /dev/null
@@ -1,31 +0,0 @@
-name: Deploy docs
-on:
-  push:
-    branches: [ master ]
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Node.js
-      uses: actions/setup-node@v1
-      with:
-        node-version: 12.x
-    - name: Set up Python
-      uses: actions/setup-python@v2
-      with:
-        python-version: 3.8
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -r local-requirements.txt
-        pip install -e .
-    - name: Generate docs
-      run: pdoc3 --html -o htmldocs playwright
-    - name: Post doc generation
-      run: node scripts/postPdoc3Generation.js
-    - name: Deploy
-      uses: peaceiris/actions-gh-pages@v3
-      with:
-        github_token: ${{ secrets.GITHUB_TOKEN }}
-        publish_dir: ./htmldocs/playwright
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
deleted file mode 100644
index 25d90fe66..000000000
--- a/.github/workflows/publish.yml
+++ /dev/null
@@ -1,67 +0,0 @@
-name: Upload Python Package
-on:
-  release:
-    types: [published]
-jobs:
-  deploy-pypi:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - uses: microsoft/playwright-github-action@v1
-    - name: Set up Node.js
-      uses: actions/setup-node@v1
-      with:
-        node-version: 12.x
-    - name: Set up Python
-      uses: actions/setup-python@v2
-      with:
-        python-version: 3.8
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -r local-requirements.txt
-        pip install -e .
-    - name: Build package
-      run: python setup.py bdist_wheel
-    - name: Publish package
-      env:
-        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
-        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
-      run: twine upload dist/*
-  publish-docker:
-    name: "publish to DockerHub"
-    runs-on: ubuntu-20.04
-    if: github.repository == 'microsoft/playwright-python'
-    steps:
-    - uses: actions/checkout@v2
-    - uses: azure/docker-login@v1
-      with:
-        login-server: playwright.azurecr.io
-        username: playwright
-        password: ${{ secrets.DOCKER_PASSWORD }}
-    - uses: microsoft/playwright-github-action@v1
-    - name: Set up Python
-      uses: actions/setup-python@v2
-      with:
-        python-version: 3.8
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -r local-requirements.txt
-        pip install -e .
-    - name: Build package
-      run: python setup.py bdist_wheel
-    - name: Install
-      run: python -m playwright install
-    - name: Build Docker image
-      run: docker build -t playwright-python:localbuild .
-    - name: tag & publish
-      run: |
-        # GITHUB_REF has a form of `refs/tags/v1.3.0`.
-        # TAG_NAME would be `v1.3.0`
-        TAG_NAME=${GITHUB_REF#refs/tags/}
-        ./scripts/tag_image_and_push.sh playwright-python:localbuild playwright.azurecr.io/public/playwright-python:latest
-        ./scripts/tag_image_and_push.sh playwright-python:localbuild playwright.azurecr.io/public/playwright-python:${TAG_NAME}
-
-        ./scripts/tag_image_and_push.sh playwright-python:localbuild playwright.azurecr.io/public/playwright-python:focal
-        ./scripts/tag_image_and_push.sh playwright-python:localbuild playwright.azurecr.io/public/playwright-python:${TAG_NAME}-focal
diff --git a/.github/workflows/publish_canary_docker.yml b/.github/workflows/publish_canary_docker.yml
deleted file mode 100644
index 429537823..000000000
--- a/.github/workflows/publish_canary_docker.yml
+++ /dev/null
@@ -1,42 +0,0 @@
-name: "devrelease:docker"
-
-on:
-  push:
-    branches:
-      - master
-      - release-*
-    paths:
-      - .github/workflows/publish_canary_docker.yml
-
-jobs:
-  publish-canary-docker:
-    name: "publish to DockerHub"
-    runs-on: ubuntu-20.04
-    if: github.repository == 'microsoft/playwright-python'
-    steps:
-    - uses: actions/checkout@v2
-    - uses: azure/docker-login@v1
-      with:
-        login-server: playwright.azurecr.io
-        username: playwright
-        password: ${{ secrets.DOCKER_PASSWORD }}
-    - uses: microsoft/playwright-github-action@v1
-    - name: Set up Python
-      uses: actions/setup-python@v2
-      with:
-        python-version: 3.8
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -r local-requirements.txt
-        pip install -e .
-    - name: Build package
-      run: python setup.py bdist_wheel
-    - name: Install
-      run: python -m playwright install
-    - run: docker build -t playwright-python:localbuild .
-    - name: tag & publish
-      run: |
-        ./scripts/tag_image_and_push.sh playwright-python:localbuild playwright.azurecr.io/public/playwright-python:next
-        ./scripts/tag_image_and_push.sh playwright-python:localbuild playwright.azurecr.io/public/playwright-python:next-focal
-        ./scripts/tag_image_and_push.sh playwright-python:localbuild playwright.azurecr.io/public/playwright-python:sha-${{ github.sha }}
diff --git a/.github/workflows/publish_docker.yml b/.github/workflows/publish_docker.yml
new file mode 100644
index 000000000..83fa5b9b9
--- /dev/null
+++ b/.github/workflows/publish_docker.yml
@@ -0,0 +1,41 @@
+name: "publish release - Docker"
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+  publish-docker-release:
+    name: "publish to DockerHub"
+    runs-on: ubuntu-22.04
+    if: github.repository == 'microsoft/playwright-python'
+    permissions:
+      id-token: write   # This is required for OIDC login (azure/login) to succeed
+      contents: read    # This is required for actions/checkout to succeed
+    environment: Docker
+    steps:
+    - uses: actions/checkout@v6
+    - name: Azure login
+      uses: azure/login@v3
+      with:
+        client-id: ${{ secrets.AZURE_DOCKER_CLIENT_ID }}
+        tenant-id: ${{ secrets.AZURE_DOCKER_TENANT_ID }}
+        subscription-id: ${{ secrets.AZURE_DOCKER_SUBSCRIPTION_ID }}
+    - name: Login to ACR via OIDC
+      run: az acr login --name playwright
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: "3.10"
+    - name: Set up Docker QEMU for arm64 docker builds
+      uses: docker/setup-qemu-action@v4
+      with:
+        platforms: arm64
+    - name: Install dependencies & browsers
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r local-requirements.txt
+        pip install -r requirements.txt
+        pip install -e .
+    - run: ./utils/docker/publish_docker.sh stable
diff --git a/.github/workflows/test_docker.yml b/.github/workflows/test_docker.yml
index 07c55007a..a25a382b5 100644
--- a/.github/workflows/test_docker.yml
+++ b/.github/workflows/test_docker.yml
@@ -3,40 +3,56 @@ on:
   push:
     paths:
       - '.github/workflows/test_docker.yml'
+      - 'setup.py'
+      - '**/Dockerfile.*'
     branches:
-      - master
+      - main
+      - release-*
   pull_request:
     paths:
       - '.github/workflows/test_docker.yml'
+      - 'setup.py'
+      - '**/Dockerfile.*'
     branches:
-      - master
+      - main
+      - release-*
 jobs:
   build:
-    timeout-minutes: 60
-    runs-on: ubuntu-20.04
+    timeout-minutes: 120
+    runs-on: ${{ matrix.runs-on }}
+    strategy:
+      fail-fast: false
+      matrix:
+        docker-image-variant:
+          - jammy
+          - noble
+        runs-on:
+          - ubuntu-24.04
+          - ubuntu-24.04-arm
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v6
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v6
       with:
-        python-version: 3.8
+        python-version: "3.10"
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
         pip install -r local-requirements.txt
+        pip install -r requirements.txt
         pip install -e .
-    - name: Build package
-      run: python setup.py bdist_wheel
-    - name: Install
-      run: python -m playwright install
     - name: Build Docker image
-      run: docker build -t playwright-python:localbuild .
+      run: |
+        ARCH="${{ matrix.runs-on == 'ubuntu-24.04-arm' && 'arm64' || 'amd64' }}"
+        bash utils/docker/build.sh --$ARCH ${{ matrix.docker-image-variant }} playwright-python:localbuild-${{ matrix.docker-image-variant }}
     - name: Test
       run: |
-        CONTAINER_ID="$(docker run --rm -v $(pwd):/root/playwright --name playwright-docker-test -d -t playwright-python:localbuild /bin/bash)"
-        docker exec --workdir /root/playwright/ "${CONTAINER_ID}" pip install -r local-requirements.txt
-        docker exec --workdir /root/playwright/ "${CONTAINER_ID}" pip install -e .
-        docker exec --workdir /root/playwright/ "${CONTAINER_ID}" python setup.py bdist_wheel
-        docker exec --workdir /root/playwright/ "${CONTAINER_ID}" xvfb-run pytest -vv tests/common/
-        docker exec --workdir /root/playwright/ "${CONTAINER_ID}" xvfb-run pytest -vv tests/sync/
-        docker exec --workdir /root/playwright/ "${CONTAINER_ID}" xvfb-run pytest -vv tests/async/
+        CONTAINER_ID="$(docker run --rm -e CI -v $(pwd):/root/playwright --name playwright-docker-test --workdir /root/playwright/ -d -t playwright-python:localbuild-${{ matrix.docker-image-variant }} /bin/bash)"
+        # Fix permissions for Git inside the container
+        docker exec "${CONTAINER_ID}" chown -R root:root /root/playwright
+        docker exec "${CONTAINER_ID}" pip install -r local-requirements.txt
+        docker exec "${CONTAINER_ID}" pip install -r requirements.txt
+        docker exec "${CONTAINER_ID}" pip install -e .
+        docker exec "${CONTAINER_ID}" python -m build --wheel
+        docker exec "${CONTAINER_ID}" xvfb-run pytest tests/sync/
+        docker exec "${CONTAINER_ID}" xvfb-run pytest tests/async/
diff --git a/.gitignore b/.gitignore
index 2fdbc6aab..8424e9bfc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,13 +1,15 @@
-playwright/__pycache__/
+**/__pycache__/
 driver/
 playwright/driver/
 playwright.egg-info/
 build/
 dist/
+venv/
+.idea/
 **/*.pyc
 env/
 htmlcov/
-.coverage
+.coverage*
 .DS_Store
 .vscode/
 .eggs
@@ -15,3 +17,7 @@ _repo_version.py
 coverage.xml
 junit/
 htmldocs/
+utils/docker/dist/
+Pipfile
+Pipfile.lock
+.venv/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index fb427c8f3..57fdca816 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,26 +1,49 @@
 # See https://pre-commit.com for more information
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
--   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v3.2.0
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
     hooks:
-    -   id: trailing-whitespace
-    -   id: end-of-file-fixer
-        exclude: ^playwright/drivers/browsers.json$
-    -   id: check-yaml
--   repo: https://github.com/psf/black
-    rev: 20.8b1
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+        exclude: tests/assets/har-sha1-main-response.txt
+      - id: check-yaml
+      - id: check-toml
+      - id: requirements-txt-fixer
+      - id: check-ast
+      - id: check-builtin-literals
+      - id: check-executables-have-shebangs
+      - id: check-merge-conflict
+  - repo: https://github.com/psf/black
+    rev: 25.1.0
     hooks:
-    -   id: black
--   repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.782
+      - id: black
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.17.0
     hooks:
-    -   id: mypy
--   repo: https://gitlab.com/pycqa/flake8
-    rev: '3.8.3'
+      - id: mypy
+        additional_dependencies: [types-pyOpenSSL==24.1.0.20240722, types-requests==2.32.4.20250611]
+  - repo: https://github.com/pycqa/flake8
+    rev: 7.3.0
     hooks:
-    -   id: flake8
--   repo: https://github.com/pycqa/isort
-    rev: 5.5.4
+      - id: flake8
+  - repo: https://github.com/pycqa/isort
+    rev: 6.0.1
     hooks:
-    -   id: isort
+      - id: isort
+  - repo: local
+    hooks:
+      - id: pyright
+        name: pyright
+        entry: pyright
+        language: node
+        pass_filenames: false
+        types: [python]
+        additional_dependencies: ["pyright@1.1.403"]
+  - repo: local
+    hooks:
+      - id: check-license-header
+        name: Check License Header
+        entry: ./utils/linting/check_file_header.py
+        language: python
+        types: [python]
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 000000000..1cbaf3e1a
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,98 @@
+# CLAUDE.md
+
+Guidance for Claude when working in this repository.
+
+## What this is
+
+Python bindings for [Playwright](https://playwright.dev). The Python client talks JSON over a pipe to the Node-based driver bundled in `playwright/driver/`. The pipe protocol is defined upstream in `packages/protocol/src/protocol.yml`.
+
+## Layout
+
+- `playwright/_impl/` — hand-written client implementation (one module per object: `_browser.py`, `_page.py`, `_locator.py`, `_network.py`, etc.). Edit these to add or change behavior.
+- `playwright/async_api/_generated.py`, `playwright/sync_api/_generated.py` — **auto-generated**. Never edit by hand; rerun `./scripts/update_api.sh` after changing `_impl/` or the driver.
+- `scripts/generate_api.py`, `scripts/generate_async_api.py`, `scripts/generate_sync_api.py`, `scripts/documentation_provider.py` — codegen and validation. They diff the Python implementation against the driver's `playwright/driver/package/api.json` and abort if either side is out of sync.
+- `scripts/expected_api_mismatch.txt` — explicit allowlist of "documented in JS, not in Python" or "named differently in Python" gaps. Lines that no longer apply must be removed.
+- `tests/async/`, `tests/sync/` — pytest suites. Most new tests are added to the async file with a sync mirror.
+- `setup.py` — `driver_version = "X.Y.Z"` is the source of truth for which driver build is downloaded from `cdn.playwright.dev`.
+- `ROLLING.md`, `CONTRIBUTING.md` — human-facing setup and roll docs.
+
+## Setup
+
+`CONTRIBUTING.md` has the full sequence. The short version:
+
+```sh
+python3 -m venv env && source env/bin/activate
+pip install --upgrade pip
+pip install -r local-requirements.txt
+pip install -e .
+python -m build --wheel        # downloads the driver listed in setup.py
+pre-commit install
+```
+
+If the system lacks `python3-venv`, `uv venv env` is an acceptable substitute (then `uv pip install --python env/bin/python --upgrade pip`).
+
+## Common commands
+
+- Regenerate `_generated.py`: `./scripts/update_api.sh` (runs codegen + pre-commit on the generated files).
+- Lint everything: `pre-commit run --all-files`.
+- Type-check: `mypy playwright`.
+- Run tests: `pytest --browser chromium [-k name]`. Browsers are installed via `playwright install chromium` (do **not** use `--with-deps`, which requires sudo).
+
+When changing public API, edit `_impl/`, then run `./scripts/update_api.sh`. The script regenerates `_generated.py` and validates against the driver's `api.json`. If validation fails, fix the mismatch in `_impl/`, in `expected_api_mismatch.txt`, or in `documentation_provider.py` — not by hand-editing `_generated.py`.
+
+## Rolling Playwright to a new version
+
+This is the recurring high-stakes task. Use the dedicated skill:
+
+→ **[`.claude/skills/playwright-roll/SKILL.md`](.claude/skills/playwright-roll/SKILL.md)**
+
+It documents the full process: the upstream commit-range diff over `docs/src/api/`, how to classify each commit (PORT / MISMATCH / N/A), how to handle the `langs:` filter, the recurring failure modes, and the tests/sync-mirroring conventions.
+
+## Working on PRs
+
+- Never post comments, replies, or reviews on GitHub PRs/issues under my account without my explicit approval. Draft the proposed text and wait for me to approve before sending.
+
+## House style
+
+- Don't hand-edit generated files.
+- Don't add `# type: ignore` or modify `_generated.py` to silence pyright; fix the source of the mismatch.
+- New public methods on impl classes need a sync test mirror under `tests/sync/`.
+- Keep `expected_api_mismatch.txt` minimal — every entry needs a one-line rationale comment above it.
+- Prefer `locals_to_params(locals())` for forwarding optional kwargs to channel sends, matching the rest of the codebase.
+
+## Commit Convention
+
+Before committing, run `mypy playwright` and fix errors.
+
+Semantic commit messages: `label(scope): description`
+
+Labels: `fix`, `feat`, `chore`, `docs`, `test`, `devops`
+
+```bash
+git checkout -b fix-12345
+# ... make changes ...
+git add <changed-files>
+git commit -m "$(cat <<'EOF'
+fix(asyncio): do not deadlock in atexit handler
+
+Fixes: https://github.com/microsoft/playwright-python/issues/12345
+EOF
+)"
+git push origin fix-12345
+gh pr create --repo microsoft/playwright-python --head username:fix-12345 \
+  --title "fix(asyncio): do not deadlock in atexit handler" \
+  --body "$(cat <<'EOF'
+## Summary
+- <describe the change very! briefly>
+
+Fixes https://github.com/microsoft/playwright-python/issues/12345
+EOF
+)"
+```
+
+Never add Co-Authored-By agents in commit message.
+Never add "Generated with" in commit message.
+Never add test plan to PR description. Keep PR description short — a few bullet points at most.
+Branch naming for issue fixes: `fix-<issue-number>`
+
+**Never `git push` without an explicit instruction to push.** Applies even when a PR is already open for the branch — additional commits are immediately visible to reviewers. Commit locally, report what was committed, and wait. Only push when the user's message contains "push", "upload", "create PR", "ship it", or equivalent.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index baae7aa6f..b59e281c8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,23 +4,55 @@
 
 ### Configuring python environment
 
-The project requires python version 3.8+. To set it as default in the environment run the following commands:
+The project development requires Python version 3.9+. To set it as default in the environment run the following commands:
 
-```bash
-python3.8 -m venv env
+```sh
+# You may need to install python 3.9 venv if it's missing, on Ubuntu just run `sudo apt-get install python3.9-venv`
+python3.9 -m venv env
 source ./env/bin/activate
 ```
 
 Install required dependencies:
 
-```bash
-python -m pip install --upgrade pip wheel
+```sh
+python -m pip install --upgrade pip
 pip install -r local-requirements.txt
+```
+
+Build and install drivers:
+
+```sh
 pip install -e .
-python setup.py bdist_wheel
+python -m build --wheel
+```
+
+Run tests:
+
+```sh
+pytest --browser chromium
+```
+
+Checking for typing errors
+
+```sh
+mypy playwright
 ```
 
-For more details look at the [CI configuration](./blob/master/.github/workflows/ci.yml).
+Format the code
+
+```sh
+pre-commit install
+pre-commit run --all-files
+```
+
+For more details look at the [CI configuration](./.github/workflows/ci.yml).
+
+Collect coverage
+
+```sh
+pytest --browser chromium --cov-report html --cov=playwright
+open htmlcov/index.html
+```
 
 ### Regenerating APIs
 
@@ -31,7 +63,7 @@ pre-commit run --all-files
 
 ## Contributor License Agreement
 
-This project welcomes contributions and suggestions.  Most contributions require you to agree to a
+This project welcomes contributions and suggestions. Most contributions require you to agree to a
 Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
 the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.
 
diff --git a/Dockerfile b/Dockerfile
deleted file mode 100644
index 053e99a95..000000000
--- a/Dockerfile
+++ /dev/null
@@ -1,80 +0,0 @@
-FROM ubuntu:focal
-
-# 1. Install latest Python
-RUN apt-get update && apt-get install -y python3 python3-pip && \
-    update-alternatives --install /usr/bin/pip pip /usr/bin/pip3 1 && \
-    update-alternatives --install /usr/bin/python python /usr/bin/python3 1
-
-# 2. Install WebKit dependencies
-RUN apt-get update && DEBIAN_FRONTEND="noninteractive" apt-get install -y --no-install-recommends \
-    libwoff1 \
-    libopus0 \
-    libwebp6 \
-    libwebpdemux2 \
-    libenchant1c2a \
-    libgudev-1.0-0 \
-    libsecret-1-0 \
-    libhyphen0 \
-    libgdk-pixbuf2.0-0 \
-    libegl1 \
-    libnotify4 \
-    libxslt1.1 \
-    libevent-2.1-7 \
-    libgles2 \
-    libxcomposite1 \
-    libatk1.0-0 \
-    libatk-bridge2.0-0 \
-    libepoxy0 \
-    libgtk-3-0 \
-    libharfbuzz-icu0
-
-# 3. Install gstreamer and plugins to support video playback in WebKit.
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libgstreamer-gl1.0-0 \
-    libgstreamer-plugins-bad1.0-0 \
-    gstreamer1.0-plugins-good \
-    gstreamer1.0-libav
-
-# 4. Install Chromium dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libnss3 \
-    libxss1 \
-    libasound2 \
-    fonts-noto-color-emoji \
-    libxtst6
-
-# 5. Install Firefox dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libdbus-glib-1-2 \
-    libxt6
-
-# 6. Install ffmpeg to bring in audio and video codecs necessary for playing videos in Firefox.
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    ffmpeg
-
-# 7. (Optional) Install XVFB if there's a need to run browsers in headful mode
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    xvfb
-
-# 8. Feature-parity with node.js base images.
-RUN apt-get update && apt-get install -y --no-install-recommends git ssh
-
-# 9. Create the pwuser (we internally create a symlink for the pwuser and the root user)
-RUN adduser pwuser
-
-# === BAKE BROWSERS INTO IMAGE ===
-
-# 1. Add tip-of-tree Playwright Python package to install its browsers.
-#    The package should be built beforehand from tip-of-tree Playwright.
-COPY ./dist/playwright*manylinux1*.whl /tmp/playwright-1.0-py3-none-manylinux1_x86_64.whl
-
-# 2. Install playwright and then delete the installation.
-#    Browsers will remain downloaded in `/home/pwuser/.cache/ms-playwright`.
-RUN su pwuser -c "mkdir /tmp/pw && cd /tmp/pw && \
-    pip install /tmp/playwright-1.0-py3-none-manylinux1_x86_64.whl && \
-    python -m playwright install" && \
-    rm -rf /tmp/pw && rm /tmp/playwright-1.0-py3-none-manylinux1_x86_64.whl
-
-# 3. Symlink downloaded browsers for root user
-RUN mkdir /root/.cache/ && \
-    ln -s /home/pwuser/.cache/ms-playwright/ /root/.cache/ms-playwright
diff --git a/README.md b/README.md
index 24831b343..c9ce32470 100644
--- a/README.md
+++ b/README.md
@@ -1,342 +1,54 @@
-# 🎭 [Playwright](https://playwright.dev) for Python [![PyPI version](https://badge.fury.io/py/playwright.svg)](https://pypi.python.org/pypi/playwright/) [![Join Slack](https://img.shields.io/badge/join-slack-infomational)](https://join.slack.com/t/playwright/shared_invite/enQtOTEyMTUxMzgxMjIwLThjMDUxZmIyNTRiMTJjNjIyMzdmZDA3MTQxZWUwZTFjZjQwNGYxZGM5MzRmNzZlMWI5ZWUyOTkzMjE5Njg1NDg)
+# 🎭 [Playwright](https://playwright.dev) for Python [![PyPI](https://badge.fury.io/py/playwright.svg)](https://pypi.python.org/pypi/playwright/) [![Join Discord](https://img.shields.io/badge/join-discord-infomational)](https://aka.ms/playwright/discord)
 
-#### [Docs](#documentation) | [Website](https://playwright.dev/) | [Python API reference](https://microsoft.github.io/playwright-python/)
-
-Playwright is a Python library to automate [Chromium](https://www.chromium.org/Home), [Firefox](https://www.mozilla.org/en-US/firefox/new/) and [WebKit](https://webkit.org/) browsers with a single API. Playwright delivers automation that is **ever-green**, **capable**, **reliable** and **fast**. [See how Playwright is better](https://playwright.dev/#path=docs%2Fwhy-playwright.md&q=).
+Playwright is a Python library to automate [Chromium](https://www.chromium.org/Home), [Firefox](https://www.mozilla.org/en-US/firefox/new/) and [WebKit](https://webkit.org/) browsers with a single API. Playwright delivers automation that is **ever-green**, **capable**, **reliable** and **fast**. [See how Playwright is better](https://playwright.dev/python).
 
 |          | Linux | macOS | Windows |
 |   :---   | :---: | :---: | :---:   |
-| Chromium <!-- GEN:chromium-version -->89.0.4344.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| WebKit <!-- GEN:webkit-version -->14.1<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->84.0b9<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-
-Headless execution is supported for all browsers on all platforms.
-
-* [Usage](#usage)
-  - [Record and generate code](#record-and-generate-code)
-  - [Sync API](#sync-api)
-  - [Async API](#async-api)
-  - [With pytest](#with-pytest)
-  - [Interactive mode (REPL)](#interactive-mode-repl)
-* [Examples](#examples)
-  - [Mobile and geolocation](#mobile-and-geolocation)
-  - [Evaluate JS in browser](#evaluate-js-in-browser)
-  - [Intercept network requests](#intercept-network-requests)
-* [Documentation](#documentation)
-
-## Usage
-
-```sh
-pip install playwright
-python -m playwright install
-```
-
-This installs Playwright and browser binaries for Chromium, Firefox and WebKit. Playwright requires Python 3.7+.
+| Chromium <!-- GEN:chromium-version -->148.0.7778.96<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| WebKit <!-- GEN:webkit-version -->26.4<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->150.0.2<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
-#### Record and generate code
+## Documentation
 
-Playwright can record user interactions in a browser and generate code. [See demo](https://user-images.githubusercontent.com/284612/95930164-ad52fb80-0d7a-11eb-852d-04bfd19de800.gif).
+[https://playwright.dev/python/docs/intro](https://playwright.dev/python/docs/intro)
 
-```sh
-# Pass --help to see all options
-python -m playwright codegen
-```
+## API Reference
 
-Playwright offers both sync (blocking) API and async API. They are identical in terms of capabilities and only differ in how one consumes the API.
+[https://playwright.dev/python/docs/api/class-playwright](https://playwright.dev/python/docs/api/class-playwright)
 
-#### Sync API
+## Example
 
 ```py
-from playwright import sync_playwright
+from playwright.sync_api import sync_playwright
 
 with sync_playwright() as p:
     for browser_type in [p.chromium, p.firefox, p.webkit]:
         browser = browser_type.launch()
-        page = browser.newPage()
-        page.goto('http://whatsmyuseragent.org/')
+        page = browser.new_page()
+        page.goto('http://playwright.dev')
         page.screenshot(path=f'example-{browser_type.name}.png')
         browser.close()
 ```
 
-#### Async API
-
 ```py
 import asyncio
-from playwright import async_playwright
+from playwright.async_api import async_playwright
 
 async def main():
     async with async_playwright() as p:
         for browser_type in [p.chromium, p.firefox, p.webkit]:
             browser = await browser_type.launch()
-            page = await browser.newPage()
-            await page.goto('http://whatsmyuseragent.org/')
+            page = await browser.new_page()
+            await page.goto('http://playwright.dev')
             await page.screenshot(path=f'example-{browser_type.name}.png')
             await browser.close()
 
-asyncio.get_event_loop().run_until_complete(main())
-```
-
-#### With pytest
-
-Use our [pytest plugin for Playwright](https://github.com/microsoft/playwright-pytest#readme).
-
-```py
-def test_playwright_is_visible_on_google(page):
-    page.goto("https://www.google.com")
-    page.type("input[name=q]", "Playwright GitHub")
-    page.click("input[type=submit]")
-    page.waitForSelector("text=microsoft/Playwright")
-```
-
-#### Interactive mode (REPL)
-
-```py
->>> from playwright import sync_playwright
->>> playwright = sync_playwright().start()
-
-# Use playwright.chromium, playwright.firefox or playwright.webkit
-# Pass headless=False to see the browser UI
->>> browser = playwright.chromium.launch()
->>> page = browser.newPage()
->>> page.goto("http://whatsmyuseragent.org/")
->>> page.screenshot(path="example.png")
->>> browser.close()
->>> playwright.stop()
-```
-
-## Examples
-
-#### Mobile and geolocation
-
-This snippet emulates Mobile Safari on a device at a given geolocation, navigates to maps.google.com, performs action and takes a screenshot.
-
-```py
-from playwright import sync_playwright
-
-with sync_playwright() as p:
-    iphone_11 = p.devices['iPhone 11 Pro']
-    browser = p.webkit.launch(headless=False)
-    context = browser.newContext(
-        **iphone_11,
-        locale='en-US',
-        geolocation={ 'longitude': 12.492507, 'latitude': 41.889938 },
-        permissions=['geolocation']
-    )
-    page = context.newPage()
-    page.goto('https://maps.google.com')
-    page.click('text="Your location"')
-    page.screenshot(path='colosseum-iphone.png')
-    browser.close()
-```
-
-<details>
-<summary>Async variant</summary>
-
-```py
-import asyncio
-from playwright import async_playwright
-
-async def main():
-    async with async_playwright() as p:
-        iphone_11 = p.devices['iPhone 11 Pro']
-        browser = await p.webkit.launch(headless=False)
-        context = await browser.newContext(
-            **iphone_11,
-            locale='en-US',
-            geolocation={ 'longitude': 12.492507, 'latitude': 41.889938 },
-            permissions=['geolocation']
-        )
-        page = await context.newPage()
-        await page.goto('https://maps.google.com')
-        await page.click('text="Your location"')
-        await page.screenshot(path='colosseum-iphone.png')
-        await browser.close()
-
-asyncio.get_event_loop().run_until_complete(main())
-```
-</details>
-
-#### Evaluate JS in browser
-
-This code snippet navigates to example.com in Firefox, and executes a script in the page context.
-
-```py
-from playwright import sync_playwright
-
-with sync_playwright() as p:
-    browser = p.firefox.launch()
-    page = browser.newPage()
-    page.goto('https://www.example.com/')
-    dimensions = page.evaluate('''() => {
-      return {
-        width: document.documentElement.clientWidth,
-        height: document.documentElement.clientHeight,
-        deviceScaleFactor: window.devicePixelRatio
-      }
-    }''')
-    print(dimensions)
-    browser.close()
-```
-<details>
-<summary>Async variant</summary>
-
-```py
-import asyncio
-from playwright import async_playwright
-
-async def main():
-    async with async_playwright() as p:
-        browser = await p.firefox.launch()
-        page = await browser.newPage()
-        await page.goto('https://www.example.com/')
-        dimensions = await page.evaluate('''() => {
-          return {
-            width: document.documentElement.clientWidth,
-            height: document.documentElement.clientHeight,
-            deviceScaleFactor: window.devicePixelRatio
-          }
-        }''')
-        print(dimensions)
-        await browser.close()
-
-asyncio.get_event_loop().run_until_complete(main())
-```
-</details>
-
-#### Intercept network requests
-
-This code snippet sets up request routing for a Chromium page to log all network requests.
-
-```py
-from playwright import sync_playwright
-
-with sync_playwright() as p:
-    browser = p.chromium.launch()
-    page = browser.newPage()
-
-    def log_and_continue_request(route, request):
-      print(request.url)
-      route.continue_()
-
-    # Log and continue all network requests
-    page.route('**', lambda route, request: log_and_continue_request(route, request))
-
-    page.goto('http://todomvc.com')
-    browser.close()
-```
-<details>
-<summary>Async variant</summary>
-
-```py
-import asyncio
-from playwright import async_playwright
-
-async def main():
-    async with async_playwright() as p:
-        browser = await p.chromium.launch()
-        page = await browser.newPage()
-
-        def log_and_continue_request(route, request):
-            print(request.url)
-            asyncio.create_task(route.continue_())
-
-        # Log and continue all network requests
-        await page.route('**', lambda route, request: log_and_continue_request(route, request))
-
-        await page.goto('http://todomvc.com')
-        await browser.close()
-
-asyncio.get_event_loop().run_until_complete(main())
-```
-</details>
-
-## Documentation
-
-We are in the process of converting our [documentation](https://playwright.dev/) from the Node.js form to Python. You can go ahead and use the Node.js documentation since the API is pretty much the same. Playwright uses non-Python naming conventions (`camelCase` instead of `snake_case`) for its methods. We recognize that this is not ideal, but it was done deliberately, so that you could rely upon Stack Overflow answers and existing documentation.
-
-### Named arguments
-
-Since Python allows named arguments, we didn't need to put the `options` parameter into every call as in the Node.js API. So when you see example like this in JavaScript
-
-```js
-await webkit.launch({ headless: false });
-```
-
-It translates into Python like this:
-
-```py
-webkit.launch(headless=False)
+asyncio.run(main())
 ```
 
-If you are using an IDE, it will suggest parameters that are available in every call.
-
-### Evaluating functions
-
-Another difference is that in the JavaScript version, `page.evaluate` accepts JavaScript functions, while this does not make any sense in the Python version.
-
-In JavaScript it will be documented as:
-
-```js
-const result = await page.evaluate(([x, y]) => {
-  return Promise.resolve(x * y);
-}, [7, 8]);
-console.log(result); // prints "56"
-```
-
-And in Python that would look like:
-
-```py
-result = page.evaluate("""
-    ([x, y]) => {
-        return Promise.resolve(x * y);
-    }""",
-    [7, 8])
-print(result) # prints "56"
-```
-
-The library will detect that what are passing it is a function and will invoke it with the given parameters. You can opt out of this function detection and pass `force_expr=True` to all evaluate functions, but you probably will never need to do that.
-
-### Using context managers
-
-Python enabled us to do some of the things that were not possible in the Node.js version and we used the opportunity. Instead of using the `page.waitFor*` methods, we recommend using corresponding `page.expect_*` context manager.
-
-In JavaScript it will be documented as:
-
-```js
-const [ download ] = await Promise.all([
-  page.waitForEvent('download'), // <-- start waiting for the download
-  page.click('button#delayed-download') // <-- perform the action that directly or indirectly initiates it.
-]);
-const path = await download.path();
-```
-
-And in Python that would look much simpler:
-
-```py
-with page.expect_download() as download_info:
-    page.click("button#delayed-download")
-download = download_info.value
-path = download.path()
-```
-
-Similarly, for waiting for the network response:
-
-```js
-const [response] = await Promise.all([
-  page.waitForResponse('**/api/fetch_data'),
-  page.click('button#update'),
-]);
-```
-
-Becomes
-
-```py
-with page.expect_response("**/api/fetch_data"):
-    page.click("button#update")
-```
-
-## Is Playwright for Python ready?
-
-Yes, Playwright for Python is ready. We are still not at the version v1.0, so minor breaking API changes could potentially happen. But a) this is unlikely and b) we will only do that if we know it improves your experience with the new library. We'd like to collect your feedback before we freeze the API for v1.0.
+## Other languages
 
-> Note: We don't yet support some of the edge-cases of the vendor-specific APIs such as collecting Chromium trace, coverage report, etc.
+More comfortable in another programming language? [Playwright](https://playwright.dev) is also available in
+- [Node.js (JavaScript / TypeScript)](https://playwright.dev/docs/intro),
+- [.NET](https://playwright.dev/dotnet/docs/intro),
+- [Java](https://playwright.dev/java/docs/intro).
diff --git a/ROLLING.md b/ROLLING.md
new file mode 100644
index 000000000..811d7fcb3
--- /dev/null
+++ b/ROLLING.md
@@ -0,0 +1,25 @@
+# Rolling Playwright-Python to the latest Playwright driver
+
+* checkout repo: `git clone https://github.com/microsoft/playwright-python`
+* make sure local python is 3.9
+    * create virtual environment, if don't have one: `python -m venv env`
+* activate venv: `source env/bin/activate`
+* install all deps:
+```
+python -m pip install --upgrade pip
+pip install -r local-requirements.txt
+pre-commit install
+pip install -e .
+```
+* change driver version in `setup.py`
+* download new driver: `python -m build --wheel`
+* generate API: `./scripts/update_api.sh`
+* commit changes & send PR
+* wait for bots to pass & merge the PR
+
+
+## Fix typing issues with Playwright ToT
+
+1. `cd playwright`
+1. `API_JSON_MODE=1 node utils/doclint/generateApiJson.js > ../playwright-python/playwright/driver/package/api.json`
+1. `./scripts/update_api.sh`
diff --git a/SUPPORT.md b/SUPPORT.md
new file mode 100644
index 000000000..0fd849315
--- /dev/null
+++ b/SUPPORT.md
@@ -0,0 +1,17 @@
+# Support
+
+## How to file issues and get help
+
+This project uses GitHub issues to track bugs and feature requests. Please search the [existing issues][gh-issues] before filing new ones to avoid duplicates. For new issues, file your bug or feature request as a new issue using corresponding template.
+
+For help and questions about using this project, please see the [docs site for Playwright for Python][docs].
+
+Join our community [Discord Server][discord-server] to connect with other developers using Playwright and ask questions in our 'help-playwright' forum.
+
+## Microsoft Support Policy
+
+Support for Playwright for Python is limited to the resources listed above.
+
+[gh-issues]: https://github.com/microsoft/playwright-python/issues/
+[docs]: https://playwright.dev/python/
+[discord-server]: https://aka.ms/playwright/discord
diff --git a/buildbots/assets/stub.py b/buildbots/assets/stub.py
deleted file mode 100644
index 74a8f38a9..000000000
--- a/buildbots/assets/stub.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from playwright.sync_api import sync_playwright
-
-with sync_playwright() as p:
-    for browser_type in [p.chromium, p.firefox, p.webkit]:
-        browser = browser_type.launch()
-        page = browser.new_page()
-        page.set_content("<h1>Test 123</h1>")
-        page.screenshot(path=f"{browser_type.name}.png")
-        browser.close()
diff --git a/buildbots/test-package-installations.sh b/buildbots/test-package-installations.sh
deleted file mode 100644
index d9b6ea698..000000000
--- a/buildbots/test-package-installations.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/bin/bash
-
-tmpdir=$(mktemp -d)
-base_dir=$(pwd)
-set -e
-
-# Cleanup to ensure we start fresh
-echo "Deleting driver and browsers from base installation"
-rm -rf driver
-rm -rf playwright
-rm -rf ~/.cache/ms-playwright
-
-cp buildbots/assets/stub.py "$tmpdir/main.py"
-
-cd $tmpdir
-echo "Creating virtual environment"
-virtualenv env
-source env/bin/activate
-echo "Installing Playwright Python via Wheel"
-pip install "$(echo $base_dir/dist/playwright*manylinux1*.whl)"
-echo "Installing browsers"
-python -m playwright install
-echo "Running basic tests"
-python "main.py"
-cd -
-
-test -f "$tmpdir/chromium.png"
-test -f "$tmpdir/firefox.png"
-test -f "$tmpdir/webkit.png"
-echo "Passed package installation tests successfully"
diff --git a/client.py b/client.py
deleted file mode 100644
index ad9874d80..000000000
--- a/client.py
+++ /dev/null
@@ -1,84 +0,0 @@
-# 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 playwright
-from playwright.sync_api import Playwright
-
-
-def main(playwright: Playwright) -> None:
-    browser = playwright.chromium.launch(headless=False)
-
-    print("Contexts in browser: %d" % len(browser.contexts))
-    print("Creating context...")
-    context = browser.new_context(viewport=0)
-    print("Contexts in browser: %d" % len(browser.contexts))
-    print("Pages in context: %d" % len(context.pages))
-
-    print("\nCreating page1...")
-    page1 = context.new_page()
-    print("Pages in context: %d" % len(context.pages))
-    page1.on("framenavigated", lambda frame: print("Frame navigated to %s" % frame.url))
-    page1.on("request", lambda request: print("Request %s" % request.url))
-    page1.on(
-        "requestFinished", lambda request: print("Request finished %s" % request.url)
-    )
-    page1.on(
-        "response",
-        lambda response: print(
-            "Response %s, request %s in frame %s"
-            % (response.url, response.request.url, response.frame.url)
-        ),
-    )
-    print("Navigating page1 to https://example.com...")
-    page1.goto("https://example.com")
-    print("Page1 main frame url: %s" % page1.main_frame.url)
-    print("Page1 tile: %s" % page1.title())
-    print("Frames in page1: %d" % len(page1.frames))
-    page1.screenshot(path="example.png")
-
-    print("\nCreating page2...")
-    page2 = context.new_page()
-    page2.on("framenavigated", lambda frame: print("Frame navigated to %s" % frame.url))
-
-    print("Navigating page2 to https://webkit.org...")
-    page2.goto("https://webkit.org")
-    print("Page2 tile: %s" % page2.title())
-    print("Pages in context: %d" % len(context.pages))
-
-    print("\nQuerying body...")
-    body1 = page1.query_selector("body")
-    assert body1
-    print("Body text %s" % body1.text_content())
-
-    print("Closing page1...")
-    page1.close()
-    print("Pages in context: %d" % len(context.pages))
-
-    print("Navigating page2 to https://cnn.com...")
-    page2.goto("https://cnn.com")
-    print("Page2 main frame url: %s" % page2.main_frame.url)
-    print("Page2 tile: %s" % page2.title())
-    print("Frames in page2: %d" % len(page2.frames))
-    print("Pages in context: %d" % len(context.pages))
-
-    print("Closing context...")
-    context.close()
-    print("Contexts in browser: %d" % len(browser.contexts))
-    print("Closing browser")
-    browser.close()
-
-
-if __name__ == "__main__":
-    with playwright.sync_api.sync_playwright() as p:
-        main(p)
diff --git a/docs/development.md b/docs/development.md
deleted file mode 100644
index b2c9f3c4d..000000000
--- a/docs/development.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# Development
-
-## Build driver:
-
-```sh
-pip install -e .
-python setup.py bdist_wheel
-```
-
-## Run tests:
-
-```sh
-pytest
-```
-
-## Run tests with coverage:
-
-```sh
-pytest --cov=playwright --cov-report html
-open htmlcov/index.html
-```
-
-## Deploy:
-
-```sh
-python setup.py bdist_wheel
-python setup.py upload
-```
-
-## Checking for typing errors
-
-```sh
-mypy playwright
-```
-
-## Format the code
-
-```sh
-black .
-```
-
-## Installing the Git hooks (auto format etc. on commit)
-
-```sh
-pre-commit install
-```
diff --git a/examples/todomvc/mvctests/__init__.py b/examples/todomvc/mvctests/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/examples/todomvc/mvctests/test_clear_completed_button.py b/examples/todomvc/mvctests/test_clear_completed_button.py
new file mode 100644
index 000000000..a36b5b2b0
--- /dev/null
+++ b/examples/todomvc/mvctests/test_clear_completed_button.py
@@ -0,0 +1,51 @@
+# 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.
+from typing import Generator
+
+import pytest
+
+from playwright.sync_api import Page, expect
+
+from .utils import TODO_ITEMS, create_default_todos
+
+
+@pytest.fixture(autouse=True)
+def run_around_tests(page: Page) -> Generator[None, None, None]:
+    # setup before a test
+    page.goto("https://demo.playwright.dev/todomvc")
+    create_default_todos(page)
+    # run the actual test
+    yield
+    # run any cleanup code
+
+
+def test_should_display_the_correct_text(page: Page) -> None:
+    page.locator(".todo-list li .toggle").first.check()
+    expect(page.locator(".clear-completed")).to_have_text("Clear completed")
+
+
+def test_should_clear_completed_items_when_clicked(page: Page) -> None:
+    todo_items = page.locator(".todo-list li")
+    todo_items.nth(1).locator(".toggle").check()
+    page.locator(".clear-completed").click()
+    expect(todo_items).to_have_count(2)
+    expect(todo_items).to_have_text([TODO_ITEMS[0], TODO_ITEMS[2]])
+
+
+def test_should_be_hidden_when_there_are_no_items_that_are_completed(
+    page: Page,
+) -> None:
+    page.locator(".todo-list li .toggle").first.check()
+    page.locator(".clear-completed").click()
+    expect(page.locator(".clear-completed")).to_be_hidden()
diff --git a/examples/todomvc/mvctests/test_counter.py b/examples/todomvc/mvctests/test_counter.py
new file mode 100644
index 000000000..17bc98637
--- /dev/null
+++ b/examples/todomvc/mvctests/test_counter.py
@@ -0,0 +1,41 @@
+# 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.
+from typing import Generator
+
+import pytest
+
+from playwright.sync_api import Page, expect
+
+from .utils import TODO_ITEMS, assert_number_of_todos_in_local_storage
+
+
+@pytest.fixture(autouse=True)
+def run_around_tests(page: Page) -> Generator[None, None, None]:
+    # setup before a test
+    page.goto("https://demo.playwright.dev/todomvc")
+    # run the actual test
+    yield
+    # run any cleanup code
+
+
+def test_should_display_the_current_number_of_todo_items(page: Page) -> None:
+    page.locator(".new-todo").fill(TODO_ITEMS[0])
+    page.locator(".new-todo").press("Enter")
+    expect(page.locator(".todo-count")).to_contain_text("1")
+
+    page.locator(".new-todo").fill(TODO_ITEMS[1])
+    page.locator(".new-todo").press("Enter")
+    expect(page.locator(".todo-count")).to_contain_text("2")
+
+    assert_number_of_todos_in_local_storage(page, 2)
diff --git a/examples/todomvc/mvctests/test_editing.py b/examples/todomvc/mvctests/test_editing.py
new file mode 100644
index 000000000..39d5caad6
--- /dev/null
+++ b/examples/todomvc/mvctests/test_editing.py
@@ -0,0 +1,97 @@
+# 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.
+from typing import Generator
+
+import pytest
+
+from playwright.sync_api import Page, expect
+
+from .utils import (
+    TODO_ITEMS,
+    assert_number_of_todos_in_local_storage,
+    check_todos_in_local_storage,
+    create_default_todos,
+)
+
+
+@pytest.fixture(autouse=True)
+def run_around_tests(page: Page) -> Generator[None, None, None]:
+    # setup before a test
+    page.goto("https://demo.playwright.dev/todomvc")
+    create_default_todos(page)
+    assert_number_of_todos_in_local_storage(page, 3)
+    # run the actual test
+    yield
+    # run any cleanup code
+
+
+def test_should_hide_other_controls_when_editing(page: Page) -> None:
+    todo_item = page.locator(".todo-list li").nth(1)
+    todo_item.dblclick()
+    expect(todo_item.locator(".toggle")).not_to_be_visible()
+    expect(todo_item.locator("label")).not_to_be_visible()
+    assert_number_of_todos_in_local_storage(page, 3)
+
+
+def test_should_save_edits_on_blur(page: Page) -> None:
+    todo_items = page.locator(".todo-list li")
+    todo_items.nth(1).dblclick()
+    todo_items.nth(1).locator(".edit").fill("buy some sausages")
+    todo_items.nth(1).locator(".edit").dispatch_event("blur")
+
+    expect(todo_items).to_have_text(
+        [
+            TODO_ITEMS[0],
+            "buy some sausages",
+            TODO_ITEMS[2],
+        ]
+    )
+    check_todos_in_local_storage(page, "buy some sausages")
+
+
+def test_should_trim_entered_text(page: Page) -> None:
+    todo_items = page.locator(".todo-list li")
+    todo_items.nth(1).dblclick()
+    todo_items.nth(1).locator(".edit").fill("    buy some sausages    ")
+    todo_items.nth(1).locator(".edit").press("Enter")
+
+    expect(todo_items).to_have_text(
+        [
+            TODO_ITEMS[0],
+            "buy some sausages",
+            TODO_ITEMS[2],
+        ]
+    )
+    check_todos_in_local_storage(page, "buy some sausages")
+
+
+def test_should_remove_the_item_if_an_empty_text_string_was_entered(page: Page) -> None:
+    todo_items = page.locator(".todo-list li")
+    todo_items.nth(1).dblclick()
+    todo_items.nth(1).locator(".edit").fill("")
+    todo_items.nth(1).locator(".edit").press("Enter")
+
+    expect(todo_items).to_have_text(
+        [
+            TODO_ITEMS[0],
+            TODO_ITEMS[2],
+        ]
+    )
+
+
+def test_should_cancel_edits_on_escape(page: Page) -> None:
+    todo_items = page.locator(".todo-list li")
+    todo_items.nth(1).dblclick()
+    todo_items.nth(1).locator(".edit").press("Escape")
+    expect(todo_items).to_have_text(TODO_ITEMS)
diff --git a/examples/todomvc/mvctests/test_item.py b/examples/todomvc/mvctests/test_item.py
new file mode 100644
index 000000000..99cef20f5
--- /dev/null
+++ b/examples/todomvc/mvctests/test_item.py
@@ -0,0 +1,89 @@
+# 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.
+from typing import Generator
+
+import pytest
+
+from playwright.sync_api import Page, expect
+
+from .utils import (
+    TODO_ITEMS,
+    check_number_of_completed_todos_in_local_storage,
+    check_todos_in_local_storage,
+    create_default_todos,
+)
+
+
+@pytest.fixture(autouse=True)
+def run_around_tests(page: Page) -> Generator[None, None, None]:
+    # setup before a test
+    page.goto("https://demo.playwright.dev/todomvc")
+    # run the actual test
+    yield
+    # run any cleanup code
+
+
+def test_should_allow_me_to_mark_items_as_completed(page: Page) -> None:
+    # Create two items.
+    for item in TODO_ITEMS[:2]:
+        page.locator(".new-todo").fill(item)
+        page.locator(".new-todo").press("Enter")
+
+    # Check first item.
+    firstTodo = page.locator(".todo-list li").nth(0)
+    firstTodo.locator(".toggle").check()
+    expect(firstTodo).to_have_class("completed")
+
+    # Check second item.
+    secondTodo = page.locator(".todo-list li").nth(1)
+    expect(secondTodo).not_to_have_class("completed")
+    secondTodo.locator(".toggle").check()
+
+    # Assert completed class.
+    expect(firstTodo).to_have_class("completed")
+    expect(secondTodo).to_have_class("completed")
+
+
+def test_should_allow_me_to_un_mark_items_as_completed(page: Page) -> None:
+    # Create two items.
+    for item in TODO_ITEMS[:2]:
+        page.locator(".new-todo").fill(item)
+        page.locator(".new-todo").press("Enter")
+
+    firstTodo = page.locator(".todo-list li").nth(0)
+    secondTodo = page.locator(".todo-list li").nth(1)
+    firstTodo.locator(".toggle").check()
+    expect(firstTodo).to_have_class("completed")
+    expect(secondTodo).not_to_have_class("completed")
+    check_number_of_completed_todos_in_local_storage(page, 1)
+
+    firstTodo.locator(".toggle").uncheck()
+    expect(firstTodo).not_to_have_class("completed")
+    expect(secondTodo).not_to_have_class("completed")
+    check_number_of_completed_todos_in_local_storage(page, 0)
+
+
+def test_should_allow_me_to_edit_an_item(page: Page) -> None:
+    create_default_todos(page)
+
+    todo_items = page.locator(".todo-list li")
+    secondTodo = todo_items.nth(1)
+    secondTodo.dblclick()
+    expect(secondTodo.locator(".edit")).to_have_value(TODO_ITEMS[1])
+    secondTodo.locator(".edit").fill("buy some sausages")
+    secondTodo.locator(".edit").press("Enter")
+
+    # Explicitly assert the new text value.
+    expect(todo_items).to_have_text([TODO_ITEMS[0], "buy some sausages", TODO_ITEMS[2]])
+    check_todos_in_local_storage(page, "buy some sausages")
diff --git a/examples/todomvc/mvctests/test_mark_all_as_completed.py b/examples/todomvc/mvctests/test_mark_all_as_completed.py
new file mode 100644
index 000000000..bec157bd8
--- /dev/null
+++ b/examples/todomvc/mvctests/test_mark_all_as_completed.py
@@ -0,0 +1,84 @@
+# 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.
+from typing import Generator
+
+import pytest
+
+from playwright.sync_api import Page, expect
+
+from .utils import (
+    assert_number_of_todos_in_local_storage,
+    check_number_of_completed_todos_in_local_storage,
+    create_default_todos,
+)
+
+
+@pytest.fixture(autouse=True)
+def run_around_tests(page: Page) -> Generator[None, None, None]:
+    # setup before a test
+    page.goto("https://demo.playwright.dev/todomvc")
+    # run the actual test
+    yield
+    # run any cleanup code
+
+
+def test_should_allow_me_to_mark_all_items_as_completed(page: Page) -> None:
+    create_default_todos(page)
+    assert_number_of_todos_in_local_storage(page, 3)
+    # Complete all todos.
+    page.locator(".toggle-all").check()
+
+    # Ensure all todos have 'completed' class.
+    expect(page.locator(".todo-list li")).to_have_class(
+        ["completed", "completed", "completed"]
+    )
+    check_number_of_completed_todos_in_local_storage(page, 3)
+    assert_number_of_todos_in_local_storage(page, 3)
+
+
+def test_should_allow_me_to_clear_the_complete_state_of_all_items(page: Page) -> None:
+    create_default_todos(page)
+    assert_number_of_todos_in_local_storage(page, 3)
+    # Check and then immediately uncheck.
+    page.locator(".toggle-all").check()
+    page.locator(".toggle-all").uncheck()
+
+    # Should be no completed classes.
+    expect(page.locator(".todo-list li")).to_have_class(["", "", ""])
+    assert_number_of_todos_in_local_storage(page, 3)
+
+
+def test_complete_all_checkbox_should_update_state_when_items_are_completed_or_cleared(
+    page: Page,
+) -> None:
+    create_default_todos(page)
+    assert_number_of_todos_in_local_storage(page, 3)
+    toggleAll = page.locator(".toggle-all")
+    toggleAll.check()
+    expect(toggleAll).to_be_checked()
+    check_number_of_completed_todos_in_local_storage(page, 3)
+
+    # Uncheck first todo.
+    firstTodo = page.locator(".todo-list li").nth(0)
+    firstTodo.locator(".toggle").uncheck()
+
+    # Reuse toggleAll locator and make sure its not checked.
+    expect(toggleAll).not_to_be_checked()
+
+    firstTodo.locator(".toggle").check()
+    check_number_of_completed_todos_in_local_storage(page, 3)
+
+    # Assert the toggle all is checked again.
+    expect(toggleAll).to_be_checked()
+    assert_number_of_todos_in_local_storage(page, 3)
diff --git a/examples/todomvc/mvctests/test_new_todo.py b/examples/todomvc/mvctests/test_new_todo.py
new file mode 100644
index 000000000..f9e069c7b
--- /dev/null
+++ b/examples/todomvc/mvctests/test_new_todo.py
@@ -0,0 +1,89 @@
+# 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 re
+from typing import Generator
+
+import pytest
+
+from playwright.sync_api import Page, expect
+
+from .utils import (
+    TODO_ITEMS,
+    assert_number_of_todos_in_local_storage,
+    create_default_todos,
+)
+
+
+@pytest.fixture(autouse=True)
+def run_around_tests(page: Page) -> Generator[None, None, None]:
+    # setup before a test
+    page.goto("https://demo.playwright.dev/todomvc")
+    # run the actual test
+    yield
+    # run any cleanup code
+
+
+def test_new_todo_test_should_allow_me_to_add_todo_items(page: Page) -> None:
+    # Create 1st todo.
+    page.locator(".new-todo").fill(TODO_ITEMS[0])
+    page.locator(".new-todo").press("Enter")
+
+    # Make sure the list only has one todo item.
+    expect(page.locator(".view label")).to_have_text([TODO_ITEMS[0]])
+
+    # Create 2nd todo.
+    page.locator(".new-todo").fill(TODO_ITEMS[1])
+    page.locator(".new-todo").press("Enter")
+
+    # Make sure the list now has two todo items.
+    expect(page.locator(".view label")).to_have_text([TODO_ITEMS[0], TODO_ITEMS[1]])
+
+    assert_number_of_todos_in_local_storage(page, 2)
+
+
+def test_new_todo_test_should_clear_text_input_field_when_an_item_is_added(
+    page: Page,
+) -> None:
+    # Create one todo item.
+    page.locator(".new-todo").fill(TODO_ITEMS[0])
+    page.locator(".new-todo").press("Enter")
+
+    # Check that input is empty.
+    expect(page.locator(".new-todo")).to_be_empty()
+    assert_number_of_todos_in_local_storage(page, 1)
+
+
+def test_new_todo_test_should_append_new_items_to_the_bottom_of_the_list(
+    page: Page,
+) -> None:
+    # Create 3 items.
+    create_default_todos(page)
+
+    # Check test using different methods.
+    expect(page.locator(".todo-count")).to_have_text("3 items left")
+    expect(page.locator(".todo-count")).to_contain_text("3")
+    expect(page.locator(".todo-count")).to_have_text(re.compile("3"))
+
+    # Check all items in one call.
+    expect(page.locator(".view label")).to_have_text(TODO_ITEMS)
+    assert_number_of_todos_in_local_storage(page, 3)
+
+
+def test_new_todo_should_show_main_and_foter_when_items_added(page: Page) -> None:
+    page.locator(".new-todo").fill(TODO_ITEMS[0])
+    page.locator(".new-todo").press("Enter")
+
+    expect(page.locator(".main")).to_be_visible()
+    expect(page.locator(".footer")).to_be_visible()
+    assert_number_of_todos_in_local_storage(page, 1)
diff --git a/examples/todomvc/mvctests/test_persistence.py b/examples/todomvc/mvctests/test_persistence.py
new file mode 100644
index 000000000..37457d51b
--- /dev/null
+++ b/examples/todomvc/mvctests/test_persistence.py
@@ -0,0 +1,48 @@
+# 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.
+from typing import Generator
+
+import pytest
+
+from playwright.sync_api import Page, expect
+
+from .utils import TODO_ITEMS, check_number_of_completed_todos_in_local_storage
+
+
+@pytest.fixture(autouse=True)
+def run_around_tests(page: Page) -> Generator[None, None, None]:
+    # setup before a test
+    page.goto("https://demo.playwright.dev/todomvc")
+    # run the actual test
+    yield
+    # run any cleanup code
+
+
+def test_should_persist_its_data(page: Page) -> None:
+    for item in TODO_ITEMS[:2]:
+        page.locator(".new-todo").fill(item)
+        page.locator(".new-todo").press("Enter")
+
+    todo_items = page.locator(".todo-list li")
+    todo_items.nth(0).locator(".toggle").check()
+    expect(todo_items).to_have_text([TODO_ITEMS[0], TODO_ITEMS[1]])
+    expect(todo_items).to_have_class(["completed", ""])
+
+    # Ensure there is 1 completed item.
+    check_number_of_completed_todos_in_local_storage(page, 1)
+
+    # Now reload.
+    page.reload()
+    expect(todo_items).to_have_text([TODO_ITEMS[0], TODO_ITEMS[1]])
+    expect(todo_items).to_have_class(["completed", ""])
diff --git a/examples/todomvc/mvctests/test_routing.py b/examples/todomvc/mvctests/test_routing.py
new file mode 100644
index 000000000..2d7efa3d2
--- /dev/null
+++ b/examples/todomvc/mvctests/test_routing.py
@@ -0,0 +1,94 @@
+# 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.
+from typing import Generator
+
+import pytest
+
+from playwright.sync_api import Page, expect
+
+from .utils import (
+    TODO_ITEMS,
+    check_number_of_completed_todos_in_local_storage,
+    check_todos_in_local_storage,
+    create_default_todos,
+)
+
+
+@pytest.fixture(autouse=True)
+def run_around_tests(page: Page) -> Generator[None, None, None]:
+    # setup before a test
+    page.goto("https://demo.playwright.dev/todomvc")
+    create_default_todos(page)
+    # make sure the app had a chance to save updated todos in storage
+    # before navigating to a new view, otherwise the items can get lost :(
+    # in some frameworks like Durandal
+    check_todos_in_local_storage(page, TODO_ITEMS[0])
+    # run the actual test
+    yield
+    # run any cleanup code
+
+
+def test_should_allow_me_to_display_active_item(page: Page) -> None:
+    page.locator(".todo-list li .toggle").nth(1).check()
+    check_number_of_completed_todos_in_local_storage(page, 1)
+    page.locator(".filters >> text=Active").click()
+    expect(page.locator(".todo-list li")).to_have_count(2)
+    expect(page.locator(".todo-list li")).to_have_text([TODO_ITEMS[0], TODO_ITEMS[2]])
+
+
+def test_should_respect_the_back_button(page: Page) -> None:
+    page.locator(".todo-list li .toggle").nth(1).check()
+    check_number_of_completed_todos_in_local_storage(page, 1)
+
+    # Showing all items
+    page.locator(".filters >> text=All").click()
+    expect(page.locator(".todo-list li")).to_have_count(3)
+
+    # Showing active items
+    page.locator(".filters >> text=Active").click()
+
+    # Showing completed items
+    page.locator(".filters >> text=Completed").click()
+
+    expect(page.locator(".todo-list li")).to_have_count(1)
+    page.go_back()
+    expect(page.locator(".todo-list li")).to_have_count(2)
+    page.go_back()
+    expect(page.locator(".todo-list li")).to_have_count(3)
+
+
+def test_should_allow_me_to_display_completed_items(page: Page) -> None:
+    page.locator(".todo-list li .toggle").nth(1).check()
+    check_number_of_completed_todos_in_local_storage(page, 1)
+    page.locator(".filters >> text=Completed").click()
+    expect(page.locator(".todo-list li")).to_have_count(1)
+
+
+def test_should_allow_me_to_display_all_items(page: Page) -> None:
+    page.locator(".todo-list li .toggle").nth(1).check()
+    check_number_of_completed_todos_in_local_storage(page, 1)
+    page.locator(".filters >> text=Active").click()
+    page.locator(".filters >> text=Completed").click()
+    page.locator(".filters >> text=All").click()
+    expect(page.locator(".todo-list li")).to_have_count(3)
+
+
+def test_should_highlight_the_current_applied_filter(page: Page) -> None:
+    expect(page.locator(".filters >> text=All")).to_have_class("selected")
+    page.locator(".filters >> text=Active").click()
+    # Page change - active items.
+    expect(page.locator(".filters >> text=Active")).to_have_class("selected")
+    page.locator(".filters >> text=Completed").click()
+    # Page change - completed items.
+    expect(page.locator(".filters >> text=Completed")).to_have_class("selected")
diff --git a/examples/todomvc/mvctests/utils.py b/examples/todomvc/mvctests/utils.py
new file mode 100644
index 000000000..e0bf6ae1d
--- /dev/null
+++ b/examples/todomvc/mvctests/utils.py
@@ -0,0 +1,41 @@
+# 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.
+from playwright.sync_api import Page
+
+TODO_ITEMS = ["buy some cheese", "feed the cat", "book a doctors appointment"]
+
+
+def create_default_todos(page: Page) -> None:
+    for item in TODO_ITEMS:
+        page.locator(".new-todo").fill(item)
+        page.locator(".new-todo").press("Enter")
+
+
+def check_number_of_completed_todos_in_local_storage(page: Page, expected: int) -> None:
+    assert (
+        page.evaluate(
+            "JSON.parse(localStorage['react-todos']).filter(i => i.completed).length"
+        )
+        == expected
+    )
+
+
+def assert_number_of_todos_in_local_storage(page: Page, expected: int) -> None:
+    assert len(page.evaluate("JSON.parse(localStorage['react-todos'])")) == expected
+
+
+def check_todos_in_local_storage(page: Page, title: str) -> None:
+    assert title in page.evaluate(
+        "JSON.parse(localStorage['react-todos']).map(i => i.title)"
+    )
diff --git a/examples/todomvc/requirements.txt b/examples/todomvc/requirements.txt
new file mode 100644
index 000000000..801cd515b
--- /dev/null
+++ b/examples/todomvc/requirements.txt
@@ -0,0 +1 @@
+pytest-playwright
diff --git a/local-requirements.txt b/local-requirements.txt
index 70384b335..43533b453 100644
--- a/local-requirements.txt
+++ b/local-requirements.txt
@@ -1,22 +1,23 @@
-autobahn==20.7.1
-pytest==6.1.0
-pytest-asyncio==0.14.0
-pytest-cov==2.10.1
-pytest-sugar==0.9.4
-pytest-xdist==2.1.0
-pytest-timeout==1.4.2
-flaky==3.7.0
-pixelmatch==0.2.1
-Pillow==8.0.0
-mypy==0.782
-setuptools==50.3.0
-# TODO: use PyPi version after >20.3.0 is released
-git+https://github.com/twisted/twisted.git@4ff22287cab3b54f51cee41ea2619e72d1bff2e4
-wheel==0.35.1
-black==20.8b1
-pre-commit==2.7.1
-flake8==3.8.3
-twine==3.2.0
-pyOpenSSL==19.1.0
-service_identity==18.1.0
-pdoc3==0.9.1
+asyncio-atexit==1.0.1
+autobahn==23.1.2
+black==25.1.0
+build==1.3.0
+flake8==7.3.0
+mypy==1.17.1
+objgraph==3.6.2
+Pillow==11.3.0
+pixelmatch==0.3.0
+pre-commit==3.5.0
+pyOpenSSL==26.0.0
+pytest==8.4.1
+pytest-asyncio==1.1.0
+pytest-cov==7.1.0
+pytest-repeat==0.9.4
+pytest-rerunfailures==15.1
+pytest-timeout==2.4.0
+pytest-xdist==3.8.0
+requests==2.32.5
+service_identity==24.2.0
+twisted==25.5.0
+types-pyOpenSSL==24.1.0.20240722
+types-requests==2.32.4.20260107
diff --git a/playwright/__init__.py b/playwright/__init__.py
index b537c637c..16593a9f2 100644
--- a/playwright/__init__.py
+++ b/playwright/__init__.py
@@ -16,40 +16,4 @@
 Python package `playwright` is a Python library to automate Chromium,
 Firefox and WebKit with a single API. Playwright is built to enable cross-browser
 web automation that is ever-green, capable, reliable and fast.
-For more information you'll find the documentation for the sync API [here](sync_api.html)
-and for the async API [here](async_api.html).
 """
-
-__pdoc__ = {
-    "_accessibility": False,
-    "_async_base": False,
-    "_browser": False,
-    "_browser_context": False,
-    "_browser_type": False,
-    "_cdp_session": False,
-    "_chromium_browser_context": False,
-    "_connection": False,
-    "_console_message": False,
-    "_dialog": False,
-    "_download": False,
-    "_element_handle": False,
-    "_event_context_manager": False,
-    "_file_chooser": False,
-    "_frame": False,
-    "_helper": False,
-    "_impl_to_api_mapping": False,
-    "_input": False,
-    "_js_handle": False,
-    "_main": False,
-    "_network": False,
-    "_object_factory": False,
-    "_page": False,
-    "_path_utils": False,
-    "_playwright": False,
-    "_selectors": False,
-    "_sync_base": False,
-    "_transport": False,
-    "_wait_helper": False,
-    "_async_playwright": False,
-    "_sync_playwright": False,
-}
diff --git a/playwright/__main__.py b/playwright/__main__.py
index 8677c47ba..b38ae8a95 100644
--- a/playwright/__main__.py
+++ b/playwright/__main__.py
@@ -12,15 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import subprocess
 import sys
 
-from playwright._impl._driver import compute_driver_executable
+from playwright._impl._driver import compute_driver_executable, get_driver_env
 
-driver_executable = compute_driver_executable()
-my_env = os.environ.copy()
-# VSCode's JavaScript Debug Terminal provides it but driver/pkg does not support it
-my_env.pop("NODE_OPTIONS", None)
-my_env["PW_CLI_TARGET_LANG"] = "python"
-subprocess.run([str(driver_executable), *sys.argv[1:]], env=my_env)
+
+def main() -> None:
+    try:
+        driver_executable, driver_cli = compute_driver_executable()
+        completed_process = subprocess.run(
+            [driver_executable, driver_cli, *sys.argv[1:]], env=get_driver_env()
+        )
+        sys.exit(completed_process.returncode)
+    except KeyboardInterrupt:
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/playwright/_impl/__init__.py b/playwright/_impl/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/playwright/_impl/_logger.py b/playwright/_impl/__pyinstaller/__init__.py
similarity index 57%
rename from playwright/_impl/_logger.py
rename to playwright/_impl/__pyinstaller/__init__.py
index b1e6e6ca9..a6f9feba7 100644
--- a/playwright/_impl/_logger.py
+++ b/playwright/_impl/__pyinstaller/__init__.py
@@ -13,20 +13,8 @@
 # limitations under the License.
 
 import os
-import sys
+from typing import List
 
-debug_enabled = os.environ.get("PWDEBUG") or (
-    "DEBUG" in os.environ and "pw:api" in os.environ["DEBUG"]
-)
 
-
-def init_logger() -> None:
-    if os.environ.get("PWDEBUG"):
-        os.environ["DEBUG"] = (
-            os.environ["DEBUG"] + ",pw:api" if "DEBUG" in os.environ else "pw:api"
-        )
-
-
-def log_api(text: str) -> None:
-    if debug_enabled:
-        print(f"  \033[1m\033[96mpw:api\033[0m {text}", file=sys.stderr)
+def get_hook_dirs() -> List[str]:
+    return [os.path.dirname(__file__)]
diff --git a/playwright/_impl/__pyinstaller/hook-playwright.async_api.py b/playwright/_impl/__pyinstaller/hook-playwright.async_api.py
new file mode 100644
index 000000000..0300f0c0d
--- /dev/null
+++ b/playwright/_impl/__pyinstaller/hook-playwright.async_api.py
@@ -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.
+
+from PyInstaller.utils.hooks import collect_data_files  # type: ignore
+
+datas = collect_data_files("playwright")
diff --git a/playwright/_impl/__pyinstaller/hook-playwright.sync_api.py b/playwright/_impl/__pyinstaller/hook-playwright.sync_api.py
new file mode 100644
index 000000000..0300f0c0d
--- /dev/null
+++ b/playwright/_impl/__pyinstaller/hook-playwright.sync_api.py
@@ -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.
+
+from PyInstaller.utils.hooks import collect_data_files  # type: ignore
+
+datas = collect_data_files("playwright")
diff --git a/playwright/_impl/_accessibility.py b/playwright/_impl/_accessibility.py
deleted file mode 100644
index 010b4e8c5..000000000
--- a/playwright/_impl/_accessibility.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# 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.
-
-from typing import Dict, Optional
-
-from playwright._impl._connection import Channel
-from playwright._impl._element_handle import ElementHandle
-from playwright._impl._helper import locals_to_params
-
-
-def _ax_node_from_protocol(axNode: Dict) -> Dict:
-    result = {**axNode}
-    if "valueNumber" in axNode:
-        result["value"] = axNode["valueNumber"]
-    elif "valueString" in axNode:
-        result["value"] = axNode["valueString"]
-
-    if "checked" in axNode:
-        result["checked"] = (
-            True
-            if axNode.get("checked") == "checked"
-            else (
-                False if axNode.get("checked") == "unchecked" else axNode.get("checked")
-            )
-        )
-
-    if "pressed" in axNode:
-        result["pressed"] = (
-            True
-            if axNode.get("pressed") == "pressed"
-            else (
-                False if axNode.get("pressed") == "released" else axNode.get("pressed")
-            )
-        )
-
-    if axNode.get("children"):
-        result["children"] = list(map(_ax_node_from_protocol, axNode["children"]))
-    if "valueNumber" in result:
-        del result["valueNumber"]
-    if "valueString" in result:
-        del result["valueString"]
-    return result
-
-
-class Accessibility:
-    def __init__(self, channel: Channel) -> None:
-        self._channel = channel
-        self._loop = channel._connection._loop
-        self._dispatcher_fiber = channel._connection._dispatcher_fiber
-
-    async def snapshot(
-        self, interestingOnly: bool = None, root: ElementHandle = None
-    ) -> Optional[Dict]:
-        params = locals_to_params(locals())
-        if root:
-            params["root"] = root._channel
-        result = await self._channel.send("accessibilitySnapshot", params)
-        return _ax_node_from_protocol(result) if result else None
diff --git a/playwright/_impl/_api_structures.py b/playwright/_impl/_api_structures.py
index ad76f7efb..2b9a331c2 100644
--- a/playwright/_impl/_api_structures.py
+++ b/playwright/_impl/_api_structures.py
@@ -12,35 +12,117 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import sys
-from typing import Dict, List, Optional
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Sequence, TypedDict, Union
 
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import Literal, TypedDict
-else:  # pragma: no cover
-    from typing_extensions import Literal, TypedDict
-
-# These are the structures that we like keeping in a JSON form for their potential reuse between SDKs / services.
+# These are the structures that we like keeping in a JSON form for their potential
+# reuse between SDKs / services. They are public and are a part of the
+# stable API.
 
 # Explicitly mark optional params as such for the documentation
 # If there is at least one optional param, set total=False for better mypy handling.
 
 
 class Cookie(TypedDict, total=False):
+    name: str
+    value: str
+    domain: str
+    path: str
+    expires: float
+    httpOnly: bool
+    secure: bool
+    sameSite: Literal["Lax", "None", "Strict"]
+    partitionKey: Optional[str]
+
+
+class StorageStateCookie(TypedDict, total=False):
+    name: str
+    value: str
+    domain: str
+    path: str
+    expires: float
+    httpOnly: bool
+    secure: bool
+    sameSite: Literal["Lax", "None", "Strict"]
+
+
+# TODO: We are waiting for PEP705 so SetCookieParam can be readonly and matches Cookie.
+class SetCookieParam(TypedDict, total=False):
     name: str
     value: str
     url: Optional[str]
     domain: Optional[str]
     path: Optional[str]
-    expires: Optional[int]
+    expires: Optional[float]
     httpOnly: Optional[bool]
     secure: Optional[bool]
-    sameSite: Optional[Literal["Strict", "Lax", "None"]]
+    sameSite: Optional[Literal["Lax", "None", "Strict"]]
+    partitionKey: Optional[str]
+
+
+class FloatRect(TypedDict):
+    x: float
+    y: float
+    width: float
+    height: float
+
+
+class Geolocation(TypedDict, total=False):
+    latitude: float
+    longitude: float
+    accuracy: Optional[float]
+
+
+class HttpCredentials(TypedDict, total=False):
+    username: str
+    password: str
+    origin: Optional[str]
+    send: Optional[Literal["always", "unauthorized"]]
+
+
+class LocalStorageEntry(TypedDict):
+    name: str
+    value: str
+
+
+class OriginState(TypedDict):
+    origin: str
+    localStorage: List[LocalStorageEntry]
+
+
+class PdfMargins(TypedDict, total=False):
+    top: Optional[Union[str, float]]
+    right: Optional[Union[str, float]]
+    bottom: Optional[Union[str, float]]
+    left: Optional[Union[str, float]]
+
+
+class Position(TypedDict):
+    x: float
+    y: float
+
+
+class ProxySettings(TypedDict, total=False):
+    server: str
+    bypass: Optional[str]
+    username: Optional[str]
+    password: Optional[str]
 
 
 class StorageState(TypedDict, total=False):
-    cookies: Optional[List[Cookie]]
-    origins: Optional[List[Dict]]
+    cookies: List[StorageStateCookie]
+    origins: List[OriginState]
+
+
+class ClientCertificate(TypedDict, total=False):
+    origin: str
+    certPath: Optional[Union[str, Path]]
+    cert: Optional[bytes]
+    keyPath: Optional[Union[str, Path]]
+    key: Optional[bytes]
+    pfxPath: Optional[Union[str, Path]]
+    pfx: Optional[bytes]
+    passphrase: Optional[str]
 
 
 class ResourceTiming(TypedDict):
@@ -53,3 +135,216 @@ class ResourceTiming(TypedDict):
     requestStart: float
     responseStart: float
     responseEnd: float
+
+
+class RequestSizes(TypedDict):
+    requestBodySize: int
+    requestHeadersSize: int
+    responseBodySize: int
+    responseHeadersSize: int
+
+
+class ViewportSize(TypedDict):
+    width: int
+    height: int
+
+
+class SourceLocation(TypedDict):
+    url: str
+    line: int
+    column: int
+    lineNumber: int
+    columnNumber: int
+
+
+class WebErrorLocation(TypedDict):
+    url: str
+    line: int
+    column: int
+
+
+class FilePayload(TypedDict):
+    name: str
+    mimeType: str
+    buffer: bytes
+
+
+class DropPayload(TypedDict, total=False):
+    files: Optional[
+        Union[str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]]
+    ]
+    data: Optional[Dict[str, str]]
+
+
+class RemoteAddr(TypedDict):
+    ipAddress: str
+    port: int
+
+
+class BrowserBindResult(TypedDict):
+    endpoint: str
+
+
+class SecurityDetails(TypedDict):
+    issuer: Optional[str]
+    protocol: Optional[str]
+    subjectName: Optional[str]
+    validFrom: Optional[float]
+    validTo: Optional[float]
+
+
+class NameValue(TypedDict):
+    name: str
+    value: str
+
+
+HeadersArray = List[NameValue]
+Headers = Dict[str, str]
+
+
+class ServerFilePayload(TypedDict):
+    name: str
+    mimeType: str
+    buffer: str
+
+
+class FormField(TypedDict, total=False):
+    name: str
+    value: Optional[str]
+    file: Optional[ServerFilePayload]
+
+
+class ExpectedTextValue(TypedDict, total=False):
+    string: str
+    regexSource: str
+    regexFlags: str
+    matchSubstring: bool
+    normalizeWhiteSpace: bool
+    ignoreCase: Optional[bool]
+
+
+class FrameExpectOptions(TypedDict, total=False):
+    expressionArg: Any
+    expectedText: Optional[Sequence[ExpectedTextValue]]
+    expectedNumber: Optional[float]
+    expectedValue: Optional[Any]
+    useInnerText: Optional[bool]
+    isNot: bool
+    timeout: Optional[float]
+    pseudo: Optional[str]
+
+
+class FrameExpectResult(TypedDict):
+    matches: bool
+    received: Any
+    log: List[str]
+    errorMessage: Optional[str]
+
+
+AriaRole = Literal[
+    "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",
+    "menu",
+    "menubar",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "meter",
+    "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",
+]
+
+
+class TracingGroupLocation(TypedDict):
+    file: str
+    line: Optional[int]
+    column: Optional[int]
+
+
+class DebuggerLocation(TypedDict):
+    file: str
+    line: Optional[int]
+    column: Optional[int]
+
+
+class DebuggerPausedDetails(TypedDict):
+    location: DebuggerLocation
+    title: str
+
+
+class ScreencastFrame(TypedDict):
+    data: bytes
+    viewportWidth: int
+    viewportHeight: int
diff --git a/playwright/_impl/_api_types.py b/playwright/_impl/_api_types.py
deleted file mode 100644
index 0a3682092..000000000
--- a/playwright/_impl/_api_types.py
+++ /dev/null
@@ -1,151 +0,0 @@
-# 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 sys
-from typing import Any, Dict, Optional, Tuple, Union
-
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import TypedDict
-else:  # pragma: no cover
-    from typing_extensions import TypedDict
-
-
-class Error(Exception):
-    def __init__(self, message: str, stack: str = None) -> None:
-        self.message = message
-        self.stack = stack
-        super().__init__(message)
-
-
-class TimeoutError(Error):
-    pass
-
-
-class ApiType:
-    def __eq__(self, other: Any) -> bool:
-        if isinstance(other, self.__class__):
-            return self.__dict__ == other.__dict__
-        else:
-            return False
-
-    def _to_json(self) -> Dict:
-        return filter_out_none(self.__dict__)
-
-
-class FilePayload(ApiType):
-    name: str
-    mime_type: str
-    buffer: bytes
-
-    def __init__(self, name: str, mime_type: str, buffer: bytes):
-        self.name = name
-        self.mime_type = mime_type
-        self.buffer = buffer
-
-
-class FloatRect(ApiType):
-    x: float
-    y: float
-    width: float
-    height: float
-
-    @classmethod
-    def _parse(cls, dict: Optional[Dict]) -> Optional["FloatRect"]:
-        if not dict:
-            return None
-        return FloatRect(dict["x"], dict["y"], dict["width"], dict["height"])
-
-    def __init__(self, x: float, y: float, width: float, height: float):
-        self.x = x
-        self.y = y
-        self.width = width
-        self.height = height
-
-
-class DeviceDescriptor(TypedDict):
-    user_agent: Optional[str]
-    viewport: Optional[Tuple[int, int]]
-    device_scale_factor: Optional[int]
-    is_mobile: Optional[bool]
-    has_touch: Optional[bool]
-
-
-class Geolocation(ApiType):
-    latitude: float
-    longitude: float
-    accuracy: Optional[float]
-
-    def __init__(self, latitude: float, longitude: float, accuracy: float = None):
-        self.latitude = latitude
-        self.longitude = longitude
-        self.accuracy = accuracy
-
-
-class PdfMargins(ApiType):
-    top: Optional[Union[str, int]]
-    right: Optional[Union[str, int]]
-    bottom: Optional[Union[str, int]]
-    left: Optional[Union[str, int]]
-
-    def __init__(
-        self,
-        top: Union[str, int],
-        right: Union[str, int],
-        bottom: Union[str, int],
-        left: Union[str, int],
-    ):
-        self.top = top
-        self.right = right
-        self.bottom = bottom
-        self.left = left
-
-
-class ProxySettings(ApiType):
-    server: str
-    bypass: Optional[str]
-    username: Optional[str]
-    password: Optional[str]
-
-    def __init__(
-        self,
-        server: str,
-        bypass: str = None,
-        username: str = None,
-        password: str = None,
-    ):
-        self.server = server
-        self.bypass = bypass
-        self.username = username
-        self.password = password
-
-
-class SourceLocation(ApiType):
-    url: str
-    line: int
-    column: int
-
-    def __init__(self, url: str, line: int, column: int):
-        self.url = url
-        self.line = line
-        self.column = column
-
-
-def filter_out_none(args: Dict) -> Any:
-    copy = {}
-    for key in args:
-        if key == "self":
-            continue
-        if args[key] is not None:
-            copy[key] = args[key]
-    return copy
diff --git a/playwright/_impl/_artifact.py b/playwright/_impl/_artifact.py
new file mode 100644
index 000000000..a08294cbe
--- /dev/null
+++ b/playwright/_impl/_artifact.py
@@ -0,0 +1,87 @@
+# 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 pathlib
+from pathlib import Path
+from typing import Dict, Optional, Union, cast
+
+from playwright._impl._connection import ChannelOwner, from_channel
+from playwright._impl._helper import Error, make_dirs_for_file, patch_error_message
+from playwright._impl._stream import Stream
+
+
+class Artifact(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self.absolute_path = initializer["absolutePath"]
+
+    async def path_after_finished(self) -> pathlib.Path:
+        if self._connection.is_remote:
+            raise Error(
+                "Path is not available when using browser_type.connect(). Use save_as() to save a local copy."
+            )
+        path = await self._channel.send(
+            "pathAfterFinished",
+            None,
+        )
+        return pathlib.Path(path)
+
+    async def save_as(self, path: Union[str, Path]) -> None:
+        stream = cast(
+            Stream,
+            from_channel(
+                await self._channel.send(
+                    "saveAsStream",
+                    None,
+                )
+            ),
+        )
+        make_dirs_for_file(path)
+        await stream.save_as(path)
+
+    async def failure(self) -> Optional[str]:
+        reason = await self._channel.send(
+            "failure",
+            None,
+        )
+        if reason is None:
+            return None
+        return patch_error_message(reason)
+
+    async def delete(self) -> None:
+        await self._channel.send(
+            "delete",
+            None,
+        )
+
+    async def read_info_buffer(self) -> bytes:
+        stream = cast(
+            Stream,
+            from_channel(
+                await self._channel.send(
+                    "stream",
+                    None,
+                )
+            ),
+        )
+        buffer = await stream.read_all()
+        return buffer
+
+    async def cancel(self) -> None:  # pyright: ignore[reportIncompatibleMethodOverride]
+        await self._channel.send(
+            "cancel",
+            None,
+        )
diff --git a/playwright/_impl/_assertions.py b/playwright/_impl/_assertions.py
new file mode 100644
index 000000000..47b4e2d8b
--- /dev/null
+++ b/playwright/_impl/_assertions.py
@@ -0,0 +1,1113 @@
+# 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 collections.abc
+from contextlib import contextmanager
+from typing import Any, Iterator, List, Literal, Optional, Pattern, Sequence, Union
+from urllib.parse import urljoin
+
+from playwright._impl._api_structures import (
+    AriaRole,
+    ExpectedTextValue,
+    FrameExpectOptions,
+    FrameExpectResult,
+)
+from playwright._impl._connection import format_call_log
+from playwright._impl._errors import Error
+from playwright._impl._fetch import APIResponse
+from playwright._impl._helper import is_textual_mime_type
+from playwright._impl._js_handle import parse_value
+from playwright._impl._locator import Locator
+from playwright._impl._page import Page
+from playwright._impl._str_utils import escape_regex_flags
+
+_soft_errors: Optional[List[AssertionError]] = None
+
+
+@contextmanager
+def _soft_scope() -> Iterator[List[AssertionError]]:
+    global _soft_errors
+    assert _soft_errors is None, "nested soft assertion scopes are not supported"
+    _soft_errors = []
+    try:
+        yield _soft_errors
+    finally:
+        _soft_errors = None
+
+
+def _record_soft_or_raise(error: AssertionError, is_soft: bool) -> None:
+    __tracebackhide__ = True
+    if is_soft:
+        if _soft_errors is None:
+            raise RuntimeError(
+                "expect.soft(...) requires pytest-playwright>=0.7.3 "
+                "(or pytest-playwright-asyncio>=0.7.3). Upgrade the plugin, "
+                "or use a regular expect(...) assertion."
+            )
+        _soft_errors.append(error)
+        return
+    raise error
+
+
+class AssertionsBase:
+    def __init__(
+        self,
+        locator: Locator,
+        timeout: float = None,
+        is_not: bool = False,
+        message: Optional[str] = None,
+        is_soft: bool = False,
+    ) -> None:
+        self._actual_locator = locator
+        self._loop = locator._loop
+        self._dispatcher_fiber = locator._dispatcher_fiber
+        self._timeout = timeout
+        self._is_not = is_not
+        self._custom_message = message
+        self._is_soft = is_soft
+
+    async def _call_expect(
+        self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
+    ) -> FrameExpectResult:
+        raise NotImplementedError(
+            "_call_expect must be implemented in a derived class."
+        )
+
+    async def _expect_impl(
+        self,
+        expression: str,
+        expect_options: FrameExpectOptions,
+        expected: Any,
+        message: str,
+        title: str = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expect_options["isNot"] = self._is_not
+        if expect_options.get("timeout") is None:
+            expect_options["timeout"] = self._timeout or 5_000
+        if expect_options["isNot"]:
+            message = message.replace("expected to", "expected not to")
+        if "useInnerText" in expect_options and expect_options["useInnerText"] is None:
+            del expect_options["useInnerText"]
+        result = await self._call_expect(expression, expect_options, title)
+        if result["matches"] == self._is_not:
+            received = result.get("received") or {}
+            aria_snapshot = None
+            if isinstance(received, dict):
+                aria_snapshot = received.get("ariaSnapshot")
+                value = received.get("value")
+                actual = parse_value(value) if value is not None else None
+            else:
+                actual = received
+            if self._custom_message:
+                out_message = self._custom_message
+                if expected is not None:
+                    out_message += f"\nExpected value: '{expected or '<None>'}'"
+            else:
+                out_message = (
+                    f"{message} '{expected}'" if expected is not None else f"{message}"
+                )
+            error_message = result.get("errorMessage")
+            error_message = f"\n{error_message}" if error_message else ""
+            aria_snapshot_message = (
+                f"\nAria snapshot:\n{aria_snapshot}" if aria_snapshot else ""
+            )
+            _record_soft_or_raise(
+                AssertionError(
+                    f"{out_message}\nActual value: {actual}{error_message} {format_call_log(result.get('log'))}{aria_snapshot_message}"
+                ),
+                self._is_soft,
+            )
+
+
+class PageAssertions(AssertionsBase):
+    def __init__(
+        self,
+        page: Page,
+        timeout: float = None,
+        is_not: bool = False,
+        message: Optional[str] = None,
+        is_soft: bool = False,
+    ) -> None:
+        super().__init__(page.locator(":root"), timeout, is_not, message, is_soft)
+        self._actual_page = page
+
+    async def _call_expect(
+        self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
+    ) -> FrameExpectResult:
+        __tracebackhide__ = True
+        return await self._actual_page.main_frame._expect(
+            None, expression, expect_options, title
+        )
+
+    @property
+    def _not(self) -> "PageAssertions":
+        return PageAssertions(
+            self._actual_page,
+            self._timeout,
+            not self._is_not,
+            self._custom_message,
+            self._is_soft,
+        )
+
+    async def to_have_title(
+        self, titleOrRegExp: Union[Pattern[str], str], timeout: float = None
+    ) -> None:
+        __tracebackhide__ = True
+        expected_values = to_expected_text_values(
+            [titleOrRegExp], normalize_white_space=True
+        )
+        await self._expect_impl(
+            "to.have.title",
+            FrameExpectOptions(expectedText=expected_values, timeout=timeout),
+            titleOrRegExp,
+            "Page title expected to be",
+            'Expect "to_have_title"',
+        )
+
+    async def not_to_have_title(
+        self, titleOrRegExp: Union[Pattern[str], str], timeout: float = None
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_title(titleOrRegExp, timeout)
+
+    async def to_have_url(
+        self,
+        urlOrRegExp: Union[str, Pattern[str]],
+        timeout: float = None,
+        ignoreCase: bool = None,
+    ) -> None:
+        __tracebackhide__ = True
+        base_url = self._actual_page.context._base_url
+        if isinstance(urlOrRegExp, str) and base_url:
+            urlOrRegExp = urljoin(base_url, urlOrRegExp)
+        expected_text = to_expected_text_values([urlOrRegExp], ignoreCase=ignoreCase)
+        await self._expect_impl(
+            "to.have.url",
+            FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+            urlOrRegExp,
+            "Page URL expected to be",
+            'Expect "to_have_url"',
+        )
+
+    async def not_to_have_url(
+        self,
+        urlOrRegExp: Union[Pattern[str], str],
+        timeout: float = None,
+        ignoreCase: bool = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_url(urlOrRegExp, timeout, ignoreCase)
+
+    async def to_match_aria_snapshot(
+        self, expected: str, timeout: float = None
+    ) -> None:
+        __tracebackhide__ = True
+        await self._expect_impl(
+            "to.match.aria",
+            FrameExpectOptions(expectedValue=expected, timeout=timeout),
+            expected,
+            "Page expected to match Aria snapshot",
+            'Expect "to_match_aria_snapshot"',
+        )
+
+    async def not_to_match_aria_snapshot(
+        self, expected: str, timeout: float = None
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_match_aria_snapshot(expected, timeout)
+
+
+class LocatorAssertions(AssertionsBase):
+    def __init__(
+        self,
+        locator: Locator,
+        timeout: float = None,
+        is_not: bool = False,
+        message: Optional[str] = None,
+        is_soft: bool = False,
+    ) -> None:
+        super().__init__(locator, timeout, is_not, message, is_soft)
+        self._actual_locator = locator
+
+    async def _call_expect(
+        self, expression: str, expect_options: FrameExpectOptions, title: Optional[str]
+    ) -> FrameExpectResult:
+        __tracebackhide__ = True
+        return await self._actual_locator._expect(expression, expect_options, title)
+
+    @property
+    def _not(self) -> "LocatorAssertions":
+        return LocatorAssertions(
+            self._actual_locator,
+            self._timeout,
+            not self._is_not,
+            self._custom_message,
+            self._is_soft,
+        )
+
+    async def to_contain_text(
+        self,
+        expected: Union[
+            Sequence[str],
+            Sequence[Pattern[str]],
+            Sequence[Union[Pattern[str], str]],
+            Pattern[str],
+            str,
+        ],
+        useInnerText: bool = None,
+        timeout: float = None,
+        ignoreCase: bool = None,
+    ) -> None:
+        __tracebackhide__ = True
+        if isinstance(expected, collections.abc.Sequence) and not isinstance(
+            expected, str
+        ):
+            expected_text = to_expected_text_values(
+                expected,
+                match_substring=True,
+                normalize_white_space=True,
+                ignoreCase=ignoreCase,
+            )
+            await self._expect_impl(
+                "to.contain.text.array",
+                FrameExpectOptions(
+                    expectedText=expected_text,
+                    useInnerText=useInnerText,
+                    timeout=timeout,
+                ),
+                expected,
+                "Locator expected to contain text",
+                'Expect "to_contain_text"',
+            )
+        else:
+            expected_text = to_expected_text_values(
+                [expected],
+                match_substring=True,
+                normalize_white_space=True,
+                ignoreCase=ignoreCase,
+            )
+            await self._expect_impl(
+                "to.have.text",
+                FrameExpectOptions(
+                    expectedText=expected_text,
+                    useInnerText=useInnerText,
+                    timeout=timeout,
+                ),
+                expected,
+                "Locator expected to contain text",
+                'Expect "to_contain_text"',
+            )
+
+    async def not_to_contain_text(
+        self,
+        expected: Union[
+            Sequence[str],
+            Sequence[Pattern[str]],
+            Sequence[Union[Pattern[str], str]],
+            Pattern[str],
+            str,
+        ],
+        useInnerText: bool = None,
+        timeout: float = None,
+        ignoreCase: bool = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_contain_text(expected, useInnerText, timeout, ignoreCase)
+
+    async def to_have_attribute(
+        self,
+        name: str,
+        value: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expected_text = to_expected_text_values([value], ignoreCase=ignoreCase)
+        await self._expect_impl(
+            "to.have.attribute.value",
+            FrameExpectOptions(
+                expressionArg=name, expectedText=expected_text, timeout=timeout
+            ),
+            value,
+            "Locator expected to have attribute",
+            'Expect "to_have_attribute"',
+        )
+
+    async def not_to_have_attribute(
+        self,
+        name: str,
+        value: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_attribute(
+            name, value, ignoreCase=ignoreCase, timeout=timeout
+        )
+
+    async def to_have_class(
+        self,
+        expected: Union[
+            Sequence[str],
+            Sequence[Pattern[str]],
+            Sequence[Union[Pattern[str], str]],
+            Pattern[str],
+            str,
+        ],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        if isinstance(expected, collections.abc.Sequence) and not isinstance(
+            expected, str
+        ):
+            expected_text = to_expected_text_values(expected)
+            await self._expect_impl(
+                "to.have.class.array",
+                FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+                expected,
+                "Locator expected to have class",
+                'Expect "to_have_class"',
+            )
+        else:
+            expected_text = to_expected_text_values([expected])
+            await self._expect_impl(
+                "to.have.class",
+                FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+                expected,
+                "Locator expected to have class",
+                'Expect "to_have_class"',
+            )
+
+    async def not_to_have_class(
+        self,
+        expected: Union[
+            Sequence[str],
+            Sequence[Pattern[str]],
+            Sequence[Union[Pattern[str], str]],
+            Pattern[str],
+            str,
+        ],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_class(expected, timeout)
+
+    async def to_contain_class(
+        self,
+        expected: Union[
+            Sequence[str],
+            str,
+        ],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        if isinstance(expected, collections.abc.Sequence) and not isinstance(
+            expected, str
+        ):
+            expected_text = to_expected_text_values(expected)
+            await self._expect_impl(
+                "to.contain.class.array",
+                FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+                expected,
+                "Locator expected to contain class names",
+                'Expect "to_contain_class"',
+            )
+        else:
+            expected_text = to_expected_text_values([expected])
+            await self._expect_impl(
+                "to.contain.class",
+                FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+                expected,
+                "Locator expected to contain class",
+                'Expect "to_contain_class"',
+            )
+
+    async def not_to_contain_class(
+        self,
+        expected: Union[
+            Sequence[str],
+            str,
+        ],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_contain_class(expected, timeout)
+
+    async def to_have_count(
+        self,
+        count: int,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._expect_impl(
+            "to.have.count",
+            FrameExpectOptions(expectedNumber=count, timeout=timeout),
+            count,
+            "Locator expected to have count",
+            'Expect "to_have_count"',
+        )
+
+    async def not_to_have_count(
+        self,
+        count: int,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_count(count, timeout)
+
+    async def to_have_css(
+        self,
+        name: str,
+        value: Union[str, Pattern[str]],
+        timeout: float = None,
+        pseudo: Literal["after", "before"] = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expected_text = to_expected_text_values([value])
+        await self._expect_impl(
+            "to.have.css",
+            FrameExpectOptions(
+                expressionArg=name,
+                expectedText=expected_text,
+                timeout=timeout,
+                pseudo=pseudo,
+            ),
+            value,
+            "Locator expected to have CSS",
+            'Expect "to_have_css"',
+        )
+
+    async def not_to_have_css(
+        self,
+        name: str,
+        value: Union[str, Pattern[str]],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_css(name, value, timeout)
+
+    async def to_have_id(
+        self,
+        id: Union[str, Pattern[str]],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expected_text = to_expected_text_values([id])
+        await self._expect_impl(
+            "to.have.id",
+            FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+            id,
+            "Locator expected to have ID",
+            'Expect "to_have_id"',
+        )
+
+    async def not_to_have_id(
+        self,
+        id: Union[str, Pattern[str]],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_id(id, timeout)
+
+    async def to_have_js_property(
+        self,
+        name: str,
+        value: Any,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._expect_impl(
+            "to.have.property",
+            FrameExpectOptions(
+                expressionArg=name, expectedValue=value, timeout=timeout
+            ),
+            value,
+            "Locator expected to have JS Property",
+            'Expect "to_have_property"',
+        )
+
+    async def not_to_have_js_property(
+        self,
+        name: str,
+        value: Any,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_js_property(name, value, timeout)
+
+    async def to_have_value(
+        self,
+        value: Union[str, Pattern[str]],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expected_text = to_expected_text_values([value])
+        await self._expect_impl(
+            "to.have.value",
+            FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+            value,
+            "Locator expected to have Value",
+            'Expect "to_have_value"',
+        )
+
+    async def not_to_have_value(
+        self,
+        value: Union[str, Pattern[str]],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_value(value, timeout)
+
+    async def to_have_values(
+        self,
+        values: Union[
+            Sequence[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]]
+        ],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expected_text = to_expected_text_values(values)
+        await self._expect_impl(
+            "to.have.values",
+            FrameExpectOptions(expectedText=expected_text, timeout=timeout),
+            values,
+            "Locator expected to have Values",
+            'Expect "to_have_values"',
+        )
+
+    async def not_to_have_values(
+        self,
+        values: Union[
+            Sequence[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]]
+        ],
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_values(values, timeout)
+
+    async def to_have_text(
+        self,
+        expected: Union[
+            Sequence[str],
+            Sequence[Pattern[str]],
+            Sequence[Union[Pattern[str], str]],
+            Pattern[str],
+            str,
+        ],
+        useInnerText: bool = None,
+        timeout: float = None,
+        ignoreCase: bool = None,
+    ) -> None:
+        __tracebackhide__ = True
+        if isinstance(expected, collections.abc.Sequence) and not isinstance(
+            expected, str
+        ):
+            expected_text = to_expected_text_values(
+                expected,
+                normalize_white_space=True,
+                ignoreCase=ignoreCase,
+            )
+            await self._expect_impl(
+                "to.have.text.array",
+                FrameExpectOptions(
+                    expectedText=expected_text,
+                    useInnerText=useInnerText,
+                    timeout=timeout,
+                ),
+                expected,
+                "Locator expected to have text",
+                'Expect "to_have_text"',
+            )
+        else:
+            expected_text = to_expected_text_values(
+                [expected], normalize_white_space=True, ignoreCase=ignoreCase
+            )
+            await self._expect_impl(
+                "to.have.text",
+                FrameExpectOptions(
+                    expectedText=expected_text,
+                    useInnerText=useInnerText,
+                    timeout=timeout,
+                ),
+                expected,
+                "Locator expected to have text",
+                'Expect "to_have_text"',
+            )
+
+    async def not_to_have_text(
+        self,
+        expected: Union[
+            Sequence[str],
+            Sequence[Pattern[str]],
+            Sequence[Union[Pattern[str], str]],
+            Pattern[str],
+            str,
+        ],
+        useInnerText: bool = None,
+        timeout: float = None,
+        ignoreCase: bool = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_text(expected, useInnerText, timeout, ignoreCase)
+
+    async def to_be_attached(
+        self,
+        attached: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        if attached is None:
+            attached = True
+        attached_string = "attached" if attached else "detached"
+        await self._expect_impl(
+            ("to.be.attached" if attached else "to.be.detached"),
+            FrameExpectOptions(timeout=timeout),
+            None,
+            f"Locator expected to be {attached_string}",
+            'Expect "to_be_attached"',
+        )
+
+    async def to_be_checked(
+        self,
+        timeout: float = None,
+        checked: bool = None,
+        indeterminate: bool = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expected_value = {}
+        if indeterminate is not None:
+            expected_value["indeterminate"] = indeterminate
+        if checked is not None:
+            expected_value["checked"] = checked
+        checked_string: str
+        if indeterminate:
+            checked_string = "indeterminate"
+        else:
+            checked_string = "unchecked" if checked is False else "checked"
+        await self._expect_impl(
+            "to.be.checked",
+            FrameExpectOptions(timeout=timeout, expectedValue=expected_value),
+            None,
+            f"Locator expected to be {checked_string}",
+            'Expect "to_be_checked"',
+        )
+
+    async def not_to_be_attached(
+        self,
+        attached: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_attached(attached=attached, timeout=timeout)
+
+    async def not_to_be_checked(
+        self,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_checked(timeout)
+
+    async def to_be_disabled(
+        self,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._expect_impl(
+            "to.be.disabled",
+            FrameExpectOptions(timeout=timeout),
+            None,
+            "Locator expected to be disabled",
+            'Expect "to_be_disabled"',
+        )
+
+    async def not_to_be_disabled(
+        self,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_disabled(timeout)
+
+    async def to_be_editable(
+        self,
+        editable: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        if editable is None:
+            editable = True
+        editable_string = "editable" if editable else "readonly"
+        await self._expect_impl(
+            "to.be.editable" if editable else "to.be.readonly",
+            FrameExpectOptions(timeout=timeout),
+            None,
+            f"Locator expected to be {editable_string}",
+            'Expect "to_be_editable"',
+        )
+
+    async def not_to_be_editable(
+        self,
+        editable: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_editable(editable, timeout)
+
+    async def to_be_empty(
+        self,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._expect_impl(
+            "to.be.empty",
+            FrameExpectOptions(timeout=timeout),
+            None,
+            "Locator expected to be empty",
+            'Expect "to_be_empty"',
+        )
+
+    async def not_to_be_empty(
+        self,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_empty(timeout)
+
+    async def to_be_enabled(
+        self,
+        enabled: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        if enabled is None:
+            enabled = True
+        enabled_string = "enabled" if enabled else "disabled"
+        await self._expect_impl(
+            "to.be.enabled" if enabled else "to.be.disabled",
+            FrameExpectOptions(timeout=timeout),
+            None,
+            f"Locator expected to be {enabled_string}",
+            'Expect "to_be_enabled"',
+        )
+
+    async def not_to_be_enabled(
+        self,
+        enabled: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_enabled(enabled, timeout)
+
+    async def to_be_hidden(
+        self,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._expect_impl(
+            "to.be.hidden",
+            FrameExpectOptions(timeout=timeout),
+            None,
+            "Locator expected to be hidden",
+            'Expect "to_be_hidden"',
+        )
+
+    async def not_to_be_hidden(
+        self,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_hidden(timeout)
+
+    async def to_be_visible(
+        self,
+        visible: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        if visible is None:
+            visible = True
+        visible_string = "visible" if visible else "hidden"
+        await self._expect_impl(
+            "to.be.visible" if visible else "to.be.hidden",
+            FrameExpectOptions(timeout=timeout),
+            None,
+            f"Locator expected to be {visible_string}",
+            'Expect "to_be_visible"',
+        )
+
+    async def not_to_be_visible(
+        self,
+        visible: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_visible(visible, timeout)
+
+    async def to_be_focused(
+        self,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._expect_impl(
+            "to.be.focused",
+            FrameExpectOptions(timeout=timeout),
+            None,
+            "Locator expected to be focused",
+            'Expect "to_be_focused"',
+        )
+
+    async def not_to_be_focused(
+        self,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_focused(timeout)
+
+    async def to_be_in_viewport(
+        self,
+        ratio: float = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._expect_impl(
+            "to.be.in.viewport",
+            FrameExpectOptions(timeout=timeout, expectedNumber=ratio),
+            None,
+            "Locator expected to be in viewport",
+            'Expect "to_be_in_viewport"',
+        )
+
+    async def not_to_be_in_viewport(
+        self, ratio: float = None, timeout: float = None
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_in_viewport(ratio=ratio, timeout=timeout)
+
+    async def to_have_accessible_description(
+        self,
+        description: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expected_values = to_expected_text_values(
+            [description], ignoreCase=ignoreCase, normalize_white_space=True
+        )
+        await self._expect_impl(
+            "to.have.accessible.description",
+            FrameExpectOptions(expectedText=expected_values, timeout=timeout),
+            None,
+            "Locator expected to have accessible description",
+            'Expect "to_have_accessible_description"',
+        )
+
+    async def not_to_have_accessible_description(
+        self,
+        name: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_accessible_description(name, ignoreCase, timeout)
+
+    async def to_have_accessible_name(
+        self,
+        name: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expected_values = to_expected_text_values(
+            [name], ignoreCase=ignoreCase, normalize_white_space=True
+        )
+        await self._expect_impl(
+            "to.have.accessible.name",
+            FrameExpectOptions(expectedText=expected_values, timeout=timeout),
+            None,
+            "Locator expected to have accessible name",
+            'Expect "to_have_accessible_name"',
+        )
+
+    async def not_to_have_accessible_name(
+        self,
+        name: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_accessible_name(name, ignoreCase, timeout)
+
+    async def to_have_role(self, role: AriaRole, timeout: float = None) -> None:
+        __tracebackhide__ = True
+        if isinstance(role, Pattern):
+            raise Error('"role" argument in to_have_role must be a string')
+        expected_values = to_expected_text_values([role])
+        await self._expect_impl(
+            "to.have.role",
+            FrameExpectOptions(expectedText=expected_values, timeout=timeout),
+            None,
+            "Locator expected to have accessible role",
+            'Expect "to_have_role"',
+        )
+
+    async def to_have_accessible_error_message(
+        self,
+        errorMessage: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        expected_values = to_expected_text_values(
+            [errorMessage], ignoreCase=ignoreCase, normalize_white_space=True
+        )
+        await self._expect_impl(
+            "to.have.accessible.error.message",
+            FrameExpectOptions(expectedText=expected_values, timeout=timeout),
+            None,
+            "Locator expected to have accessible error message",
+            'Expect "to_have_accessible_error_message"',
+        )
+
+    async def not_to_have_accessible_error_message(
+        self,
+        errorMessage: Union[str, Pattern[str]],
+        ignoreCase: bool = None,
+        timeout: float = None,
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_accessible_error_message(
+            errorMessage=errorMessage, ignoreCase=ignoreCase, timeout=timeout
+        )
+
+    async def not_to_have_role(self, role: AriaRole, timeout: float = None) -> None:
+        __tracebackhide__ = True
+        await self._not.to_have_role(role, timeout)
+
+    async def to_match_aria_snapshot(
+        self, expected: str, timeout: float = None
+    ) -> None:
+        __tracebackhide__ = True
+        await self._expect_impl(
+            "to.match.aria",
+            FrameExpectOptions(expectedValue=expected, timeout=timeout),
+            expected,
+            "Locator expected to match Aria snapshot",
+            'Expect "to_match_aria_snapshot"',
+        )
+
+    async def not_to_match_aria_snapshot(
+        self, expected: str, timeout: float = None
+    ) -> None:
+        __tracebackhide__ = True
+        await self._not.to_match_aria_snapshot(expected, timeout)
+
+
+class APIResponseAssertions:
+    def __init__(
+        self,
+        response: APIResponse,
+        timeout: float = None,
+        is_not: bool = False,
+        message: Optional[str] = None,
+        is_soft: bool = False,
+    ) -> None:
+        self._loop = response._loop
+        self._dispatcher_fiber = response._dispatcher_fiber
+        self._timeout = timeout
+        self._is_not = is_not
+        self._actual = response
+        self._custom_message = message
+        self._is_soft = is_soft
+
+    @property
+    def _not(self) -> "APIResponseAssertions":
+        return APIResponseAssertions(
+            self._actual,
+            self._timeout,
+            not self._is_not,
+            self._custom_message,
+            self._is_soft,
+        )
+
+    async def to_be_ok(
+        self,
+    ) -> None:
+        __tracebackhide__ = True
+        if self._is_not is not self._actual.ok:
+            return
+        message = f"Response status expected to be within [200..299] range, was '{self._actual.status}'"
+        if self._is_not:
+            message = message.replace("expected to", "expected not to")
+        out_message = self._custom_message or message
+        out_message += format_call_log(await self._actual._fetch_log())
+
+        content_type = self._actual.headers.get("content-type")
+        is_text_encoding = content_type and is_textual_mime_type(content_type)
+        text = await self._actual.text() if is_text_encoding else None
+        if text is not None:
+            out_message += f"\n Response Text:\n{text[:1000]}"
+
+        _record_soft_or_raise(AssertionError(out_message), self._is_soft)
+
+    async def not_to_be_ok(self) -> None:
+        __tracebackhide__ = True
+        await self._not.to_be_ok()
+
+
+def expected_regex(
+    pattern: Pattern[str],
+    match_substring: bool,
+    normalize_white_space: bool,
+    ignoreCase: Optional[bool] = None,
+) -> ExpectedTextValue:
+    expected = ExpectedTextValue(
+        regexSource=pattern.pattern,
+        regexFlags=escape_regex_flags(pattern),
+        matchSubstring=match_substring,
+        normalizeWhiteSpace=normalize_white_space,
+        ignoreCase=ignoreCase,
+    )
+    if expected["ignoreCase"] is None:
+        del expected["ignoreCase"]
+    return expected
+
+
+def to_expected_text_values(
+    items: Union[
+        Sequence[Pattern[str]], Sequence[str], Sequence[Union[str, Pattern[str]]]
+    ],
+    match_substring: bool = False,
+    normalize_white_space: bool = False,
+    ignoreCase: Optional[bool] = None,
+) -> Sequence[ExpectedTextValue]:
+    out: List[ExpectedTextValue] = []
+    assert isinstance(items, (list, tuple))
+    for item in items:
+        if isinstance(item, str):
+            o = ExpectedTextValue(
+                string=item,
+                matchSubstring=match_substring,
+                normalizeWhiteSpace=normalize_white_space,
+                ignoreCase=ignoreCase,
+            )
+            if o["ignoreCase"] is None:
+                del o["ignoreCase"]
+            out.append(o)
+        elif isinstance(item, Pattern):
+            out.append(
+                expected_regex(item, match_substring, normalize_white_space, ignoreCase)
+            )
+        else:
+            raise Error("value must be a string or regular expression")
+    return out
diff --git a/playwright/_impl/_async_base.py b/playwright/_impl/_async_base.py
index c07519aea..db7e5d005 100644
--- a/playwright/_impl/_async_base.py
+++ b/playwright/_impl/_async_base.py
@@ -13,7 +13,9 @@
 # limitations under the License.
 
 import asyncio
-from typing import Any, Callable, Coroutine, Generic, Optional, TypeVar, cast
+from contextlib import AbstractAsyncContextManager
+from types import TracebackType
+from typing import Any, Callable, Generic, Optional, Type, TypeVar, Union
 
 from playwright._impl._impl_to_api_mapping import ImplToApiMapping, ImplWrapper
 
@@ -21,31 +23,41 @@
 
 
 T = TypeVar("T")
+Self = TypeVar("Self", bound="AsyncContextManager")
 
 
 class AsyncEventInfo(Generic[T]):
-    def __init__(self, coroutine: Coroutine) -> None:
-        self._value: Optional[T] = None
-        self._future = asyncio.get_event_loop().create_task(coroutine)
-        self._done = False
+    def __init__(self, future: "asyncio.Future[T]") -> None:
+        self._future = future
 
     @property
     async def value(self) -> T:
-        if not self._done:
-            self._value = mapping.from_maybe_impl(await self._future)
-            self._done = True
-        return cast(T, self._value)
+        return mapping.from_maybe_impl(await self._future)
 
+    def _cancel(self) -> None:
+        self._future.cancel()
 
-class AsyncEventContextManager(Generic[T]):
-    def __init__(self, coroutine: Coroutine) -> None:
-        self._event: AsyncEventInfo = AsyncEventInfo(coroutine)
+    def is_done(self) -> bool:
+        return self._future.done()
+
+
+class AsyncEventContextManager(Generic[T], AbstractAsyncContextManager):
+    def __init__(self, future: "asyncio.Future[T]") -> None:
+        self._event = AsyncEventInfo[T](future)
 
     async def __aenter__(self) -> AsyncEventInfo[T]:
         return self._event
 
-    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        await self._event.value
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        if exc_val:
+            self._event._cancel()
+        else:
+            await self._event.value
 
 
 class AsyncBase(ImplWrapper):
@@ -56,24 +68,38 @@ def __init__(self, impl_obj: Any) -> None:
     def __str__(self) -> str:
         return self._impl_obj.__str__()
 
-    def _sync(self, future: asyncio.Future) -> Any:
-        return self._loop.run_until_complete(future)
-
-    def _wrap_handler(self, handler: Any) -> Callable[..., None]:
+    def _wrap_handler(
+        self, handler: Union[Callable[..., Any], Any]
+    ) -> Callable[..., None]:
         if callable(handler):
             return mapping.wrap_handler(handler)
         return handler
 
-    def on(self, event: str, f: Any) -> None:
+    def on(self, event: Any, f: Any) -> None:
         """Registers the function ``f`` to the event name ``event``."""
         self._impl_obj.on(event, self._wrap_handler(f))
 
-    def once(self, event: str, f: Any) -> None:
+    def once(self, event: Any, f: Any) -> None:
         """The same as ``self.on``, except that the listener is automatically
         removed after being called.
         """
         self._impl_obj.once(event, self._wrap_handler(f))
 
-    def remove_listener(self, event: str, f: Any) -> None:
+    def remove_listener(self, event: Any, f: Any) -> None:
         """Removes the function ``f`` from ``event``."""
         self._impl_obj.remove_listener(event, self._wrap_handler(f))
+
+
+class AsyncContextManager(AsyncBase):
+    async def __aenter__(self: Self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        await self.close()
+
+    async def close(self) -> None: ...
diff --git a/playwright/_impl/_browser.py b/playwright/_impl/_browser.py
index bdd72b70e..21b6e4d84 100644
--- a/playwright/_impl/_browser.py
+++ b/playwright/_impl/_browser.py
@@ -12,32 +12,54 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import json
-import sys
 from pathlib import Path
 from types import SimpleNamespace
-from typing import TYPE_CHECKING, Dict, List, Tuple, Union
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    List,
+    Optional,
+    Pattern,
+    Sequence,
+    Set,
+    Union,
+    cast,
+)
 
-from playwright._impl._api_structures import StorageState
-from playwright._impl._api_types import Geolocation, ProxySettings
+from playwright._impl._api_structures import (
+    BrowserBindResult,
+    ClientCertificate,
+    Geolocation,
+    HttpCredentials,
+    ProxySettings,
+    StorageState,
+    ViewportSize,
+)
+from playwright._impl._artifact import Artifact
 from playwright._impl._browser_context import BrowserContext
+from playwright._impl._cdp_session import CDPSession
 from playwright._impl._connection import ChannelOwner, from_channel
-from playwright._impl._helper import ColorScheme, is_safe_close_error, locals_to_params
-from playwright._impl._network import serialize_headers
+from playwright._impl._errors import is_target_closed_error
+from playwright._impl._helper import (
+    ColorScheme,
+    Contrast,
+    ForcedColors,
+    HarContentPolicy,
+    HarMode,
+    ReducedMotion,
+    ServiceWorkersPolicy,
+    locals_to_params,
+    make_dirs_for_file,
+)
 from playwright._impl._page import Page
 
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import Literal
-else:  # pragma: no cover
-    from typing_extensions import Literal
-
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._browser_type import BrowserType
 
 
 class Browser(ChannelOwner):
-
     Events = SimpleNamespace(
+        Context="context",
         Disconnected="disconnected",
     )
 
@@ -45,28 +67,72 @@ def __init__(
         self, parent: "BrowserType", type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
-        self._browser_type = parent
+        self._browser_type: Optional["BrowserType"] = None
         self._is_connected = True
-        self._is_closed_or_closing = False
+        self._should_close_connection_on_close = False
+        self._cr_tracing_path: Optional[str] = None
 
-        self._contexts: List[BrowserContext] = []
+        self._contexts: Set[BrowserContext] = set()
+        self._traces_dir: Optional[str] = None
+        self._channel.on(
+            "context",
+            lambda params: self._did_create_context(
+                cast(BrowserContext, from_channel(params["context"]))
+            ),
+        )
         self._channel.on("close", lambda _: self._on_close())
+        self._close_reason: Optional[str] = None
+
+    def __repr__(self) -> str:
+        return f"<Browser type={self._browser_type} version={self.version}>"
+
+    def _connect_to_browser_type(
+        self,
+        browser_type: "BrowserType",
+        traces_dir: Optional[str] = None,
+    ) -> None:
+        # Note: when using connect(), `browserType` is different from `this.parent`.
+        # This is why browser type is not wired up in the constructor, and instead this separate method is called later on.
+        self._browser_type = browser_type
+        self._traces_dir = traces_dir
+        for context in self._contexts:
+            self._setup_browser_context(context)
+
+    def _did_create_context(self, context: BrowserContext) -> None:
+        context._browser = self
+        self._contexts.add(context)
+        # Note: when connecting to a browser, initial contexts arrive before `_browserType` is set,
+        # and will be configured later in `ConnectToBrowserType`.
+        if self._browser_type:
+            self._setup_browser_context(context)
+        self.emit(Browser.Events.Context, context)
+
+    def _setup_browser_context(self, context: BrowserContext) -> None:
+        context._tracing._traces_dir = self._traces_dir
+        assert self._browser_type is not None
+        self._browser_type._playwright.selectors._contexts_for_selectors.add(context)
 
     def _on_close(self) -> None:
         self._is_connected = False
-        self.emit(Browser.Events.Disconnected)
-        self._is_closed_or_closing = True
+        self.emit(Browser.Events.Disconnected, self)
 
     @property
     def contexts(self) -> List[BrowserContext]:
-        return self._contexts.copy()
+        return list(self._contexts)
+
+    @property
+    def browser_type(self) -> "BrowserType":
+        assert self._browser_type is not None
+        return self._browser_type
 
-    def isConnected(self) -> bool:
+    def is_connected(self) -> bool:
         return self._is_connected
 
-    async def newContext(
+    async def new_context(
         self,
-        viewport: Union[Tuple[int, int], Literal[0]] = None,
+        viewport: ViewportSize = None,
+        screen: ViewportSize = None,
+        noViewport: bool = None,
         ignoreHTTPSErrors: bool = None,
         javaScriptEnabled: bool = None,
         bypassCSP: bool = None,
@@ -74,36 +140,53 @@ async def newContext(
         locale: str = None,
         timezoneId: str = None,
         geolocation: Geolocation = None,
-        permissions: List[str] = None,
+        permissions: Sequence[str] = None,
         extraHTTPHeaders: Dict[str, str] = None,
         offline: bool = None,
-        httpCredentials: Tuple[str, str] = None,
-        deviceScaleFactor: int = None,
+        httpCredentials: HttpCredentials = None,
+        deviceScaleFactor: float = None,
         isMobile: bool = None,
         hasTouch: bool = None,
         colorScheme: ColorScheme = None,
+        reducedMotion: ReducedMotion = None,
+        forcedColors: ForcedColors = None,
+        contrast: Contrast = None,
         acceptDownloads: bool = None,
         defaultBrowserType: str = None,
         proxy: ProxySettings = None,
         recordHarPath: Union[Path, str] = None,
         recordHarOmitContent: bool = None,
         recordVideoDir: Union[Path, str] = None,
-        recordVideoSize: Tuple[int, int] = None,
+        recordVideoSize: ViewportSize = None,
         storageState: Union[StorageState, str, Path] = None,
+        baseURL: str = None,
+        strictSelectors: bool = None,
+        serviceWorkers: ServiceWorkersPolicy = None,
+        recordHarUrlFilter: Union[Pattern[str], str] = None,
+        recordHarMode: HarMode = None,
+        recordHarContent: HarContentPolicy = None,
+        clientCertificates: List[ClientCertificate] = None,
     ) -> BrowserContext:
         params = locals_to_params(locals())
-        normalize_context_params(params)
+        assert self._browser_type is not None
+        await self._browser_type._prepare_browser_context_params(params)
 
-        channel = await self._channel.send("newContext", params)
-        context = from_channel(channel)
-        self._contexts.append(context)
-        context._browser = self
-        context._options = params
+        channel = await self._channel.send("newContext", None, params)
+        context = cast(BrowserContext, from_channel(channel))
+        await context._initialize_har_from_options(
+            record_har_content=recordHarContent,
+            record_har_mode=recordHarMode,
+            record_har_omit_content=recordHarOmitContent,
+            record_har_path=recordHarPath,
+            record_har_url_filter=recordHarUrlFilter,
+        )
         return context
 
-    async def newPage(
+    async def new_page(
         self,
-        viewport: Union[Tuple[int, int], Literal[0]] = None,
+        viewport: ViewportSize = None,
+        screen: ViewportSize = None,
+        noViewport: bool = None,
         ignoreHTTPSErrors: bool = None,
         javaScriptEnabled: bool = None,
         bypassCSP: bool = None,
@@ -111,70 +194,100 @@ async def newPage(
         locale: str = None,
         timezoneId: str = None,
         geolocation: Geolocation = None,
-        permissions: List[str] = None,
+        permissions: Sequence[str] = None,
         extraHTTPHeaders: Dict[str, str] = None,
         offline: bool = None,
-        httpCredentials: Tuple[str, str] = None,
-        deviceScaleFactor: int = None,
+        httpCredentials: HttpCredentials = None,
+        deviceScaleFactor: float = None,
         isMobile: bool = None,
         hasTouch: bool = None,
         colorScheme: ColorScheme = None,
+        forcedColors: ForcedColors = None,
+        contrast: Contrast = None,
+        reducedMotion: ReducedMotion = None,
         acceptDownloads: bool = None,
         defaultBrowserType: str = None,
         proxy: ProxySettings = None,
         recordHarPath: Union[Path, str] = None,
         recordHarOmitContent: bool = None,
         recordVideoDir: Union[Path, str] = None,
-        recordVideoSize: Tuple[int, int] = None,
+        recordVideoSize: ViewportSize = None,
         storageState: Union[StorageState, str, Path] = None,
+        baseURL: str = None,
+        strictSelectors: bool = None,
+        serviceWorkers: ServiceWorkersPolicy = None,
+        recordHarUrlFilter: Union[Pattern[str], str] = None,
+        recordHarMode: HarMode = None,
+        recordHarContent: HarContentPolicy = None,
+        clientCertificates: List[ClientCertificate] = None,
     ) -> Page:
         params = locals_to_params(locals())
-        context = await self.newContext(**params)
-        page = await context.newPage()
-        page._owned_context = context
-        context._owner_page = page
-        return page
-
-    async def close(self) -> None:
-        if self._is_closed_or_closing:
-            return
-        self._is_closed_or_closing = True
+
+        async def inner() -> Page:
+            context = await self.new_context(**params)
+            page = await context.new_page()
+            page._owned_context = context
+            context._owner_page = page
+            return page
+
+        return await self._connection.wrap_api_call(inner, title="Create page")
+
+    async def close(self, reason: str = None) -> None:
+        self._close_reason = reason
         try:
-            await self._channel.send("close")
+            if self._should_close_connection_on_close:
+                await self._connection.stop_async()
+            else:
+                await self._channel.send("close", None, {"reason": reason})
         except Exception as e:
-            if not is_safe_close_error(e):
+            if not is_target_closed_error(e):
                 raise e
 
     @property
     def version(self) -> str:
         return self._initializer["version"]
 
+    async def new_browser_cdp_session(self) -> CDPSession:
+        return from_channel(await self._channel.send("newBrowserCDPSession", None))
+
+    async def bind(
+        self,
+        title: str,
+        workspaceDir: str = None,
+        host: str = None,
+        port: int = None,
+    ) -> BrowserBindResult:
+        return await self._channel.send_return_as_dict(
+            "startServer", None, locals_to_params(locals())
+        )
+
+    async def unbind(self) -> None:
+        await self._channel.send("stopServer", None)
+
+    async def start_tracing(
+        self,
+        page: Page = None,
+        path: Union[str, Path] = None,
+        screenshots: bool = None,
+        categories: Sequence[str] = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        if page:
+            params["page"] = page._channel
+        if path:
+            self._cr_tracing_path = str(path)
+            params["path"] = str(path)
+        await self._channel.send("startTracing", None, params)
 
-def normalize_context_params(params: Dict) -> None:
-    if "viewport" in params and params["viewport"] == 0:
-        del params["viewport"]
-        params["noDefaultViewport"] = True
-    if "defaultBrowserType" in params:
-        del params["defaultBrowserType"]
-    if "extraHTTPHeaders" in params:
-        params["extraHTTPHeaders"] = serialize_headers(params["extraHTTPHeaders"])
-    if "recordHarPath" in params:
-        params["recordHar"] = {"path": str(params["recordHarPath"])}
-        if "recordHarOmitContent" in params:
-            params["recordHar"]["omitContent"] = True
-            del params["recordHarOmitContent"]
-        del params["recordHarPath"]
-    if "recordVideoDir" in params:
-        params["recordVideo"] = {"dir": str(params["recordVideoDir"])}
-        if "recordVideoSize" in params:
-            params["recordVideo"]["size"] = {
-                "width": params["recordVideoSize"][0],
-                "height": params["recordVideoSize"][1],
-            }
-            del params["recordVideoSize"]
-        del params["recordVideoDir"]
-    if "storageState" in params:
-        storageState = params["storageState"]
-        if not isinstance(storageState, dict):
-            with open(storageState, "r") as f:
-                params["storageState"] = json.load(f)
+    async def stop_tracing(self) -> bytes:
+        artifact = cast(
+            Artifact, from_channel(await self._channel.send("stopTracing", None))
+        )
+        buffer = await artifact.read_info_buffer()
+        await artifact.delete()
+        if self._cr_tracing_path:
+            make_dirs_for_file(self._cr_tracing_path)
+            with open(self._cr_tracing_path, "wb") as f:
+                f.write(buffer)
+            self._cr_tracing_path = None
+        return buffer
diff --git a/playwright/_impl/_browser_context.py b/playwright/_impl/_browser_context.py
index 2dc282499..38cccd4a3 100644
--- a/playwright/_impl/_browser_context.py
+++ b/playwright/_impl/_browser_context.py
@@ -13,55 +13,126 @@
 # limitations under the License.
 
 import asyncio
-import inspect
 import json
 from pathlib import Path
 from types import SimpleNamespace
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Pattern,
+    Sequence,
+    Set,
+    Union,
+    cast,
+)
 
-from playwright._impl._api_structures import Cookie, StorageState
-from playwright._impl._api_types import Error
-from playwright._impl._connection import ChannelOwner, from_channel
+from playwright._impl._api_structures import (
+    Cookie,
+    Geolocation,
+    SetCookieParam,
+    StorageState,
+    WebErrorLocation,
+)
+from playwright._impl._cdp_session import CDPSession
+from playwright._impl._clock import Clock
+from playwright._impl._connection import (
+    ChannelOwner,
+    from_channel,
+    from_nullable_channel,
+)
+from playwright._impl._console_message import ConsoleMessage
+from playwright._impl._debugger import Debugger
+from playwright._impl._dialog import Dialog
+from playwright._impl._disposable import Disposable, DisposableStub
+from playwright._impl._errors import Error, TargetClosedError
 from playwright._impl._event_context_manager import EventContextManagerImpl
+from playwright._impl._fetch import APIRequestContext
+from playwright._impl._frame import Frame
+from playwright._impl._har_router import HarRouter
 from playwright._impl._helper import (
-    PendingWaitEvent,
+    HarContentPolicy,
+    HarMode,
+    RouteFromHarNotFoundPolicy,
     RouteHandler,
-    RouteHandlerEntry,
+    RouteHandlerCallback,
     TimeoutSettings,
     URLMatch,
-    URLMatcher,
-    is_safe_close_error,
+    WebSocketRouteHandlerCallback,
+    async_readfile,
+    async_writefile,
     locals_to_params,
+    parse_error,
+    to_impl,
 )
-from playwright._impl._network import Request, Route, serialize_headers
-from playwright._impl._page import BindingCall, Page
-from playwright._impl._wait_helper import WaitHelper
+from playwright._impl._network import (
+    Request,
+    Response,
+    Route,
+    WebSocketRoute,
+    WebSocketRouteHandler,
+    serialize_headers,
+)
+from playwright._impl._page import BindingCall, Page, Worker
+from playwright._impl._str_utils import escape_regex_flags
+from playwright._impl._tracing import Tracing
+from playwright._impl._waiter import Waiter
+from playwright._impl._web_error import WebError
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._browser import Browser
 
 
 class BrowserContext(ChannelOwner):
-
     Events = SimpleNamespace(
+        # Deprecated in v1.56, never emitted anymore.
+        BackgroundPage="backgroundpage",
         Close="close",
+        Console="console",
+        Dialog="dialog",
+        Download="download",
+        FrameAttached="frameattached",
+        FrameDetached="framedetached",
+        FrameNavigated="framenavigated",
         Page="page",
+        PageClose="pageclose",
+        PageLoad="pageload",
+        WebError="weberror",
+        ServiceWorker="serviceworker",
+        Request="request",
+        Response="response",
+        RequestFailed="requestfailed",
+        RequestFinished="requestfinished",
     )
 
     def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        # Browser is null for browser contexts created outside of normal browser, e.g. android or electron.
+        # circular import workaround:
+        self._browser: Optional["Browser"] = None
+        if parent.__class__.__name__ == "Browser":
+            self._browser = cast("Browser", parent)
         self._pages: List[Page] = []
-        self._routes: List[RouteHandlerEntry] = []
+        self._routes: List[RouteHandler] = []
+        self._web_socket_routes: List[WebSocketRouteHandler] = []
         self._bindings: Dict[str, Any] = {}
-        self._pending_wait_for_events: List[PendingWaitEvent] = []
         self._timeout_settings = TimeoutSettings(None)
-        self._browser: Optional["Browser"] = None
         self._owner_page: Optional[Page] = None
-        self._is_closed_or_closing = False
-        self._options: Dict[str, Any] = {}
-
+        self._options: Dict[str, Any] = initializer["options"]
+        self._service_workers: Set[Worker] = set()
+        self._base_url: Optional[str] = self._options.get("baseURL")
+        self._videos_dir: Optional[str] = self._options.get("recordVideo")
+        self._tracing = cast(Tracing, from_channel(initializer["tracing"]))
+        self._debugger: Debugger = cast(Debugger, from_channel(initializer["debugger"]))
+        self._request: APIRequestContext = from_channel(initializer["requestContext"])
+        self._request._timeout_settings = self._timeout_settings
+        self._clock = Clock(self)
         self._channel.on(
             "bindingCall",
             lambda params: self._on_binding(from_channel(params["binding"])),
@@ -72,24 +143,148 @@ def __init__(
         )
         self._channel.on(
             "route",
-            lambda params: self._on_route(
-                from_channel(params.get("route")), from_channel(params.get("request"))
+            lambda params: self._loop.create_task(
+                self._on_route(
+                    from_channel(params.get("route")),
+                )
+            ),
+        )
+        self._channel.on(
+            "webSocketRoute",
+            lambda params: self._loop.create_task(
+                self._on_web_socket_route(
+                    from_channel(params["webSocketRoute"]),
+                )
+            ),
+        )
+
+        self._channel.on(
+            "serviceWorker",
+            lambda params: self._on_service_worker(from_channel(params["worker"])),
+        )
+        self._channel.on(
+            "console",
+            lambda event: self._on_console_message(event),
+        )
+
+        self._channel.on(
+            "dialog", lambda params: self._on_dialog(from_channel(params["dialog"]))
+        )
+        self._channel.on(
+            "pageError",
+            lambda params: self._on_page_error(
+                parse_error(params["error"]["error"]),
+                from_nullable_channel(params["page"]),
+                cast(
+                    WebErrorLocation,
+                    params.get("location") or {"url": "", "line": 0, "column": 0},
+                ),
+            ),
+        )
+        self._channel.on(
+            "request",
+            lambda params: self._on_request(
+                from_channel(params["request"]),
+                from_nullable_channel(params.get("page")),
+            ),
+        )
+        self._channel.on(
+            "response",
+            lambda params: self._on_response(
+                from_channel(params["response"]),
+                from_nullable_channel(params.get("page")),
+            ),
+        )
+        self._channel.on(
+            "requestFailed",
+            lambda params: self._on_request_failed(
+                from_channel(params["request"]),
+                params["responseEndTiming"],
+                params.get("failureText"),
+                from_nullable_channel(params.get("page")),
+            ),
+        )
+        self._channel.on(
+            "requestFinished",
+            lambda params: self._on_request_finished(
+                from_channel(params["request"]),
+                from_nullable_channel(params.get("response")),
+                params["responseEndTiming"],
+                from_nullable_channel(params.get("page")),
             ),
         )
+        self._closed_future: asyncio.Future = asyncio.Future()
+        self.once(
+            self.Events.Close, lambda context: self._closed_future.set_result(True)
+        )
+        self._close_reason: Optional[str] = None
+        self._har_routers: List[HarRouter] = []
+        self._set_event_to_subscription_mapping(
+            {
+                BrowserContext.Events.Console: "console",
+                BrowserContext.Events.Dialog: "dialog",
+                BrowserContext.Events.Request: "request",
+                BrowserContext.Events.Response: "response",
+                BrowserContext.Events.RequestFinished: "requestFinished",
+                BrowserContext.Events.RequestFailed: "requestFailed",
+            }
+        )
+        self._closing_or_closed = False
+
+    def __repr__(self) -> str:
+        return f"<BrowserContext browser={self.browser}>"
 
     def _on_page(self, page: Page) -> None:
-        page._set_browser_context(self)
         self._pages.append(page)
         self.emit(BrowserContext.Events.Page, page)
-
-    def _on_route(self, route: Route, request: Request) -> None:
-        for handler_entry in self._routes:
-            if handler_entry.matcher.matches(request.url):
-                result = cast(Any, handler_entry.handler)(route, request)
-                if inspect.iscoroutine(result):
-                    asyncio.create_task(result)
+        if page._opener and not page._opener.is_closed():
+            page._opener.emit(Page.Events.Popup, page)
+
+    async def _on_route(self, route: Route) -> None:
+        route._context = self
+        page = route.request._safe_page()
+        route_handlers = self._routes.copy()
+        for route_handler in route_handlers:
+            # If the page or the context was closed we stall all requests right away.
+            if (page and page._close_was_called) or self._closing_or_closed:
+                return
+            if not route_handler.matches(route.request.url):
+                continue
+            if route_handler not in self._routes:
+                continue
+            if route_handler.will_expire:
+                self._routes.remove(route_handler)
+            try:
+                handled = await route_handler.handle(route)
+            finally:
+                if len(self._routes) == 0:
+                    asyncio.create_task(
+                        self._connection.wrap_api_call(
+                            lambda: self._update_interception_patterns(), True
+                        )
+                    )
+            if handled:
                 return
-        asyncio.create_task(route.continue_())
+        try:
+            # If the page is closed or unrouteAll() was called without waiting and interception disabled,
+            # the method will throw an error - silence it.
+            await route._inner_continue(True)
+        except Exception:
+            pass
+
+    async def _on_web_socket_route(self, web_socket_route: WebSocketRoute) -> None:
+        route_handler = next(
+            (
+                route_handler
+                for route_handler in self._web_socket_routes
+                if route_handler.matches(web_socket_route.url)
+            ),
+            None,
+        )
+        if route_handler:
+            await route_handler.handle(web_socket_route)
+        else:
+            web_socket_route.connect_to_server()
 
     def _on_binding(self, binding_call: BindingCall) -> None:
         func = self._bindings.get(binding_call._initializer["name"])
@@ -97,15 +292,17 @@ def _on_binding(self, binding_call: BindingCall) -> None:
             return
         asyncio.create_task(binding_call.call(func))
 
-    def setDefaultNavigationTimeout(self, timeout: int) -> None:
-        self._timeout_settings.set_navigation_timeout(timeout)
-        self._channel.send_no_reply(
-            "setDefaultNavigationTimeoutNoReply", dict(timeout=timeout)
-        )
+    def set_default_navigation_timeout(self, timeout: float) -> None:
+        return self._set_default_navigation_timeout_impl(timeout)
 
-    def setDefaultTimeout(self, timeout: int) -> None:
-        self._timeout_settings.set_timeout(timeout)
-        self._channel.send_no_reply("setDefaultTimeoutNoReply", dict(timeout=timeout))
+    def _set_default_navigation_timeout_impl(self, timeout: Optional[float]) -> None:
+        self._timeout_settings.set_default_navigation_timeout(timeout)
+
+    def set_default_timeout(self, timeout: float) -> None:
+        return self._set_default_timeout_impl(timeout)
+
+    def _set_default_timeout_impl(self, timeout: Optional[float]) -> None:
+        self._timeout_settings.set_default_timeout(timeout)
 
     @property
     def pages(self) -> List[Page]:
@@ -115,63 +312,107 @@ def pages(self) -> List[Page]:
     def browser(self) -> Optional["Browser"]:
         return self._browser
 
-    async def newPage(self) -> Page:
+    async def _initialize_har_from_options(
+        self,
+        record_har_path: Optional[Union[Path, str]],
+        record_har_content: Optional[HarContentPolicy],
+        record_har_omit_content: Optional[bool],
+        record_har_url_filter: Optional[Union[Pattern[str], str]],
+        record_har_mode: Optional[HarMode],
+    ) -> None:
+        if not record_har_path:
+            return
+        record_har_path = str(record_har_path)
+        default_policy: HarContentPolicy = (
+            "attach" if record_har_path.endswith(".zip") else "embed"
+        )
+        content_policy: HarContentPolicy = record_har_content or (
+            "omit" if record_har_omit_content is True else default_policy
+        )
+        await self._tracing._record_into_har(
+            har=record_har_path,
+            page=None,
+            url=record_har_url_filter,
+            update_content=content_policy,
+            update_mode=(record_har_mode or "full"),
+        )
+
+    async def new_page(self) -> Page:
         if self._owner_page:
-            raise Error("Please use browser.newContext()")
-        return from_channel(await self._channel.send("newPage"))
+            raise Error("Please use browser.new_context()")
+        return from_channel(await self._channel.send("newPage", None))
 
-    async def cookies(self, urls: Union[str, List[str]] = None) -> List[Cookie]:
+    async def cookies(self, urls: Union[str, Sequence[str]] = None) -> List[Cookie]:
         if urls is None:
             urls = []
-        if not isinstance(urls, list):
+        if isinstance(urls, str):
             urls = [urls]
-        return await self._channel.send("cookies", dict(urls=urls))
-
-    async def addCookies(self, cookies: List[Cookie]) -> None:
-        await self._channel.send("addCookies", dict(cookies=cookies))
-
-    async def clearCookies(self) -> None:
-        await self._channel.send("clearCookies")
-
-    async def grantPermissions(
-        self, permissions: List[str], origin: str = None
-    ) -> None:
-        await self._channel.send("grantPermissions", locals_to_params(locals()))
+        return await self._channel.send("cookies", None, dict(urls=urls))
 
-    async def clearPermissions(self) -> None:
-        await self._channel.send("clearPermissions")
+    async def add_cookies(self, cookies: Sequence[SetCookieParam]) -> None:
+        await self._channel.send("addCookies", None, dict(cookies=cookies))
 
-    async def setGeolocation(
-        self, latitude: float, longitude: float, accuracy: Optional[float]
+    async def clear_cookies(
+        self,
+        name: Union[str, Pattern[str]] = None,
+        domain: Union[str, Pattern[str]] = None,
+        path: Union[str, Pattern[str]] = None,
     ) -> None:
         await self._channel.send(
-            "setGeolocation", {"geolocation": locals_to_params(locals())}
+            "clearCookies",
+            None,
+            {
+                "name": name if isinstance(name, str) else None,
+                "nameRegexSource": name.pattern if isinstance(name, Pattern) else None,
+                "nameRegexFlags": (
+                    escape_regex_flags(name) if isinstance(name, Pattern) else None
+                ),
+                "domain": domain if isinstance(domain, str) else None,
+                "domainRegexSource": (
+                    domain.pattern if isinstance(domain, Pattern) else None
+                ),
+                "domainRegexFlags": (
+                    escape_regex_flags(domain) if isinstance(domain, Pattern) else None
+                ),
+                "path": path if isinstance(path, str) else None,
+                "pathRegexSource": path.pattern if isinstance(path, Pattern) else None,
+                "pathRegexFlags": (
+                    escape_regex_flags(path) if isinstance(path, Pattern) else None
+                ),
+            },
         )
 
-    async def resetGeolocation(self) -> None:
-        await self._channel.send("setGeolocation", {})
+    async def grant_permissions(
+        self, permissions: Sequence[str], origin: str = None
+    ) -> None:
+        await self._channel.send("grantPermissions", None, locals_to_params(locals()))
+
+    async def clear_permissions(self) -> None:
+        await self._channel.send("clearPermissions", None)
+
+    async def set_geolocation(self, geolocation: Geolocation = None) -> None:
+        await self._channel.send("setGeolocation", None, locals_to_params(locals()))
 
-    async def setExtraHTTPHeaders(self, headers: Dict[str, str]) -> None:
+    async def set_extra_http_headers(self, headers: Dict[str, str]) -> None:
         await self._channel.send(
-            "setExtraHTTPHeaders", dict(headers=serialize_headers(headers))
+            "setExtraHTTPHeaders", None, dict(headers=serialize_headers(headers))
         )
 
-    async def setOffline(self, offline: bool) -> None:
-        await self._channel.send("setOffline", dict(offline=offline))
+    async def set_offline(self, offline: bool) -> None:
+        await self._channel.send("setOffline", None, dict(offline=offline))
 
-    async def addInitScript(
-        self, source: str = None, path: Union[str, Path] = None
-    ) -> None:
+    async def add_init_script(
+        self, script: str = None, path: Union[str, Path] = None
+    ) -> Disposable:
         if path:
-            with open(path, "r") as file:
-                source = file.read()
-        if not isinstance(source, str):
-            raise Error("Either path or source parameter must be specified")
-        await self._channel.send("addInitScript", dict(source=source))
-
-    async def exposeBinding(
-        self, name: str, binding: Callable, handle: bool = None
-    ) -> None:
+            script = (await async_readfile(path)).decode()
+        if not isinstance(script, str):
+            raise Error("Either path or script parameter must be specified")
+        return from_channel(
+            await self._channel.send("addInitScript", None, dict(source=script))
+        )
+
+    async def expose_binding(self, name: str, callback: Callable) -> Disposable:
         for page in self._pages:
             if name in page._bindings:
                 raise Error(
@@ -179,90 +420,324 @@ async def exposeBinding(
                 )
         if name in self._bindings:
             raise Error(f'Function "{name}" has been already registered')
-        self._bindings[name] = binding
-        await self._channel.send(
-            "exposeBinding", dict(name=name, needsHandle=handle or False)
+        self._bindings[name] = callback
+        return from_channel(
+            await self._channel.send("exposeBinding", None, dict(name=name))
         )
 
-    async def exposeFunction(self, name: str, binding: Callable) -> None:
-        await self.exposeBinding(name, lambda source, *args: binding(*args))
-
-    async def route(self, url: URLMatch, handler: RouteHandler) -> None:
-        self._routes.append(RouteHandlerEntry(URLMatcher(url), handler))
-        if len(self._routes) == 1:
-            await self._channel.send(
-                "setNetworkInterceptionEnabled", dict(enabled=True)
-            )
+    async def expose_function(self, name: str, callback: Callable) -> Disposable:
+        return await self.expose_binding(name, lambda source, *args: callback(*args))
+
+    async def route(
+        self, url: URLMatch, handler: RouteHandlerCallback, times: int = None
+    ) -> DisposableStub:
+        self._routes.insert(
+            0,
+            RouteHandler(
+                self._base_url,
+                url,
+                handler,
+                True if self._dispatcher_fiber else False,
+                times,
+            ),
+        )
+        await self._update_interception_patterns()
+        return DisposableStub(lambda: self.unroute(url, handler), self)
 
     async def unroute(
-        self, url: URLMatch, handler: Optional[RouteHandler] = None
+        self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None
     ) -> None:
-        self._routes = list(
-            filter(
-                lambda r: r.matcher.match != url or (handler and r.handler != handler),
-                self._routes,
-            )
+        removed = []
+        remaining = []
+        for route in self._routes:
+            if route.url != url or (handler and route.handler != handler):
+                remaining.append(route)
+            else:
+                removed.append(route)
+        await self._unroute_internal(removed, remaining, "default")
+
+    async def _unroute_internal(
+        self,
+        removed: List[RouteHandler],
+        remaining: List[RouteHandler],
+        behavior: Literal["default", "ignoreErrors", "wait"] = None,
+    ) -> None:
+        self._routes = remaining
+        if behavior is not None and behavior != "default":
+            await asyncio.gather(*map(lambda router: router.stop(behavior), removed))  # type: ignore
+        await self._update_interception_patterns()
+
+    async def route_web_socket(
+        self, url: URLMatch, handler: WebSocketRouteHandlerCallback
+    ) -> None:
+        self._web_socket_routes.insert(
+            0,
+            WebSocketRouteHandler(self._base_url, url, handler),
         )
-        if len(self._routes) == 0:
-            await self._channel.send(
-                "setNetworkInterceptionEnabled", dict(enabled=False)
+        await self._update_web_socket_interception_patterns()
+
+    def _dispose_har_routers(self) -> None:
+        for router in self._har_routers:
+            router.dispose()
+        self._har_routers = []
+
+    async def unroute_all(
+        self, behavior: Literal["default", "ignoreErrors", "wait"] = None
+    ) -> None:
+        await self._unroute_internal(self._routes, [], behavior)
+        self._dispose_har_routers()
+
+    async def route_from_har(
+        self,
+        har: Union[Path, str],
+        url: Union[Pattern[str], str] = None,
+        notFound: RouteFromHarNotFoundPolicy = None,
+        update: bool = None,
+        updateContent: Literal["attach", "embed"] = None,
+        updateMode: HarMode = None,
+    ) -> None:
+        if update:
+            await self._tracing._record_into_har(
+                har=har,
+                page=None,
+                url=url,
+                update_content=updateContent,
+                update_mode=updateMode,
             )
+            return
+        router = await HarRouter.create(
+            local_utils=self._connection.local_utils,
+            file=str(har),
+            not_found_action=notFound or "abort",
+            url_matcher=url,
+        )
+        self._har_routers.append(router)
+        await router.add_context_route(self)
 
-    async def waitForEvent(
-        self, event: str, predicate: Callable[[Any], bool] = None, timeout: int = None
-    ) -> Any:
+    async def _update_interception_patterns(self) -> None:
+        patterns = RouteHandler.prepare_interception_patterns(self._routes)
+        await self._channel.send(
+            "setNetworkInterceptionPatterns", None, {"patterns": patterns}
+        )
+
+    async def _update_web_socket_interception_patterns(self) -> None:
+        patterns = WebSocketRouteHandler.prepare_interception_patterns(
+            self._web_socket_routes
+        )
+        await self._channel.send(
+            "setWebSocketInterceptionPatterns", None, {"patterns": patterns}
+        )
+
+    def expect_event(
+        self,
+        event: str,
+        predicate: Callable = None,
+        timeout: float = None,
+    ) -> EventContextManagerImpl:
         if timeout is None:
             timeout = self._timeout_settings.timeout()
-        wait_helper = WaitHelper(self._loop)
-        wait_helper.reject_on_timeout(
-            timeout, f'Timeout while waiting for event "{event}"'
+        waiter = Waiter(self, f"browser_context.expect_event({event})")
+        waiter.reject_on_timeout(
+            timeout, f'Timeout {timeout}ms exceeded while waiting for event "{event}"'
         )
         if event != BrowserContext.Events.Close:
-            wait_helper.reject_on_event(
-                self, BrowserContext.Events.Close, Error("Context closed")
+            waiter.reject_on_event(
+                self, BrowserContext.Events.Close, lambda: TargetClosedError()
             )
-        return await wait_helper.wait_for_event(self, event, predicate)
+        waiter.wait_for_event(self, event, predicate)
+        return EventContextManagerImpl(waiter.result())
 
     def _on_close(self) -> None:
-        self._is_closed_or_closing = True
+        self._closing_or_closed = True
         if self._browser:
-            self._browser._contexts.remove(self)
+            if self in self._browser._contexts:
+                self._browser._contexts.remove(self)
+            assert self._browser._browser_type is not None
+            if (
+                self
+                in self._browser._browser_type._playwright.selectors._contexts_for_selectors
+            ):
+                self._browser._browser_type._playwright.selectors._contexts_for_selectors.remove(
+                    self
+                )
 
-        for pending_event in self._pending_wait_for_events:
-            if pending_event.event == BrowserContext.Events.Close:
-                continue
-            pending_event.reject(False, "Context")
+        self._dispose_har_routers()
+        self._tracing._reset_stack_counter()
+        self.emit(BrowserContext.Events.Close, self)
 
-        self.emit(BrowserContext.Events.Close)
+    def is_closed(self) -> bool:
+        return self._closing_or_closed
 
-    async def close(self) -> None:
-        if self._is_closed_or_closing:
+    async def close(self, reason: str = None) -> None:
+        if self._closing_or_closed:
             return
-        self._is_closed_or_closing = True
-        try:
-            await self._channel.send("close")
-        except Exception as e:
-            if not is_safe_close_error(e):
-                raise e
+        self._close_reason = reason
+        self._closing_or_closed = True
+
+        await self.request.dispose(reason=reason)
 
-    async def storageState(self, path: Union[str, Path] = None) -> StorageState:
-        result = await self._channel.send_return_as_dict("storageState")
+        async def _inner_close() -> None:
+            await self._tracing._export_all_hars()
+
+        await self._channel._connection.wrap_api_call(_inner_close, True)
+        await self._channel.send("close", None, {"reason": reason})
+        await self._closed_future
+
+    async def storage_state(
+        self, path: Union[str, Path] = None, indexedDB: bool = None
+    ) -> StorageState:
+        result = await self._channel.send_return_as_dict(
+            "storageState", None, {"indexedDB": indexedDB}
+        )
         if path:
-            with open(path, "w") as f:
-                json.dump(result, f)
+            await async_writefile(path, json.dumps(result))
         return result
 
-    def expect_event(
+    async def set_storage_state(
+        self, storageState: Union[StorageState, str, Path]
+    ) -> None:
+        if isinstance(storageState, (str, Path)):
+            state = json.loads(await async_readfile(storageState))
+        else:
+            state = storageState
+        await self._channel.send("setStorageState", None, {"storageState": state})
+
+    def _effective_close_reason(self) -> Optional[str]:
+        if self._close_reason:
+            return self._close_reason
+        if self._browser:
+            return self._browser._close_reason
+        return None
+
+    async def wait_for_event(
+        self, event: str, predicate: Callable = None, timeout: float = None
+    ) -> Any:
+        async with self.expect_event(event, predicate, timeout) as event_info:
+            pass
+        return await event_info
+
+    def expect_console_message(
         self,
-        event: str,
-        predicate: Callable[[Any], bool] = None,
-        timeout: int = None,
-    ) -> EventContextManagerImpl:
-        return EventContextManagerImpl(self.waitForEvent(event, predicate, timeout))
+        predicate: Callable[[ConsoleMessage], bool] = None,
+        timeout: float = None,
+    ) -> EventContextManagerImpl[ConsoleMessage]:
+        return self.expect_event(Page.Events.Console, predicate, timeout)
 
     def expect_page(
         self,
         predicate: Callable[[Page], bool] = None,
-        timeout: int = None,
+        timeout: float = None,
     ) -> EventContextManagerImpl[Page]:
-        return EventContextManagerImpl(self.waitForEvent("page", predicate, timeout))
+        return self.expect_event(BrowserContext.Events.Page, predicate, timeout)
+
+    def _on_service_worker(self, worker: Worker) -> None:
+        worker._context = self
+        self._service_workers.add(worker)
+        self.emit(BrowserContext.Events.ServiceWorker, worker)
+
+    def _on_request_failed(
+        self,
+        request: Request,
+        response_end_timing: float,
+        failure_text: Optional[str],
+        page: Optional[Page],
+    ) -> None:
+        request._failure_text = failure_text
+        request._set_response_end_timing(response_end_timing)
+        self.emit(BrowserContext.Events.RequestFailed, request)
+        if page:
+            page.emit(Page.Events.RequestFailed, request)
+
+    def _on_request_finished(
+        self,
+        request: Request,
+        response: Optional[Response],
+        response_end_timing: float,
+        page: Optional[Page],
+    ) -> None:
+        request._set_response_end_timing(response_end_timing)
+        self.emit(BrowserContext.Events.RequestFinished, request)
+        if page:
+            page.emit(Page.Events.RequestFinished, request)
+        if response:
+            response._finished_future.set_result(True)
+
+    def _on_console_message(self, event: Dict) -> None:
+        message = ConsoleMessage(event, self._loop, self._dispatcher_fiber)
+        worker = message.worker
+        if worker:
+            worker.emit(Worker.Events.Console, message)
+        page = message.page
+        if page:
+            page.emit(Page.Events.Console, message)
+        self.emit(BrowserContext.Events.Console, message)
+
+    def _on_dialog(self, dialog: Dialog) -> None:
+        has_listeners = self.emit(BrowserContext.Events.Dialog, dialog)
+        page = dialog.page
+        if page:
+            has_listeners = page.emit(Page.Events.Dialog, dialog) or has_listeners
+        if not has_listeners:
+            # Although we do similar handling on the server side, we still need this logic
+            # on the client side due to a possible race condition between two async calls:
+            # a) removing "dialog" listener subscription (client->server)
+            # b) actual "dialog" event (server->client)
+            if dialog.type == "beforeunload":
+                asyncio.create_task(dialog.accept())
+            else:
+                asyncio.create_task(dialog.dismiss())
+
+    def _on_page_error(
+        self, error: Error, page: Optional[Page], location: WebErrorLocation
+    ) -> None:
+        self.emit(
+            BrowserContext.Events.WebError,
+            WebError(self._loop, self._dispatcher_fiber, page, error, location),
+        )
+        if page:
+            page.emit(Page.Events.PageError, error)
+
+    def _on_request(self, request: Request, page: Optional[Page]) -> None:
+        self.emit(BrowserContext.Events.Request, request)
+        if page:
+            page.emit(Page.Events.Request, request)
+
+    def _on_response(self, response: Response, page: Optional[Page]) -> None:
+        self.emit(BrowserContext.Events.Response, response)
+        if page:
+            page.emit(Page.Events.Response, response)
+
+    @property
+    def background_pages(self) -> List[Page]:
+        return []
+
+    @property
+    def service_workers(self) -> List[Worker]:
+        return list(self._service_workers)
+
+    async def new_cdp_session(self, page: Union[Page, Frame]) -> CDPSession:
+        page = to_impl(page)
+        params = {}
+        if isinstance(page, Page):
+            params["page"] = page._channel
+        elif isinstance(page, Frame):
+            params["frame"] = page._channel
+        else:
+            raise Error("page: expected Page or Frame")
+        return from_channel(await self._channel.send("newCDPSession", None, params))
+
+    @property
+    def tracing(self) -> Tracing:
+        return self._tracing
+
+    @property
+    def debugger(self) -> Debugger:
+        return self._debugger
+
+    @property
+    def request(self) -> "APIRequestContext":
+        return self._request
+
+    @property
+    def clock(self) -> Clock:
+        return self._clock
diff --git a/playwright/_impl/_browser_type.py b/playwright/_impl/_browser_type.py
index 2948c90b2..8abac6061 100644
--- a/playwright/_impl/_browser_type.py
+++ b/playwright/_impl/_browser_type.py
@@ -12,25 +12,44 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
+import json
+import pathlib
 import sys
 from pathlib import Path
-from typing import Dict, List, Tuple, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Pattern, Sequence, Union, cast
 
-from playwright._impl._api_types import Geolocation, ProxySettings
-from playwright._impl._browser import Browser, normalize_context_params
+from playwright._impl._api_structures import (
+    ClientCertificate,
+    Geolocation,
+    HttpCredentials,
+    ProxySettings,
+    ViewportSize,
+)
+from playwright._impl._browser import Browser
 from playwright._impl._browser_context import BrowserContext
-from playwright._impl._connection import ChannelOwner, from_channel
+from playwright._impl._connection import ChannelOwner, Connection, from_channel
+from playwright._impl._errors import Error
 from playwright._impl._helper import (
+    PLAYWRIGHT_MAX_DEADLINE,
     ColorScheme,
+    Contrast,
     Env,
+    ForcedColors,
+    HarContentPolicy,
+    HarMode,
+    ReducedMotion,
+    ServiceWorkersPolicy,
+    TimeoutSettings,
+    async_readfile,
     locals_to_params,
-    not_installed_error,
 )
+from playwright._impl._json_pipe import JsonPipeTransport
+from playwright._impl._network import serialize_headers, to_client_certificates_protocol
+from playwright._impl._waiter import throw_on_timeout
 
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import Literal
-else:  # pragma: no cover
-    from typing_extensions import Literal
+if TYPE_CHECKING:
+    from playwright._impl._playwright import Playwright
 
 
 class BrowserType(ChannelOwner):
@@ -38,59 +57,73 @@ def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        self._playwright: "Playwright"
+
+    def __repr__(self) -> str:
+        return f"<BrowserType name={self.name} executable_path={self.executable_path}>"
 
     @property
     def name(self) -> str:
         return self._initializer["name"]
 
     @property
-    def executablePath(self) -> str:
+    def executable_path(self) -> str:
         return self._initializer["executablePath"]
 
     async def launch(
         self,
         executablePath: Union[str, Path] = None,
-        args: List[str] = None,
-        ignoreDefaultArgs: Union[bool, List[str]] = None,
+        channel: str = None,
+        args: Sequence[str] = None,
+        ignoreDefaultArgs: Union[bool, Sequence[str]] = None,
         handleSIGINT: bool = None,
         handleSIGTERM: bool = None,
         handleSIGHUP: bool = None,
-        timeout: int = None,
+        timeout: float = None,
         env: Env = None,
         headless: bool = None,
-        devtools: bool = None,
         proxy: ProxySettings = None,
         downloadsPath: Union[str, Path] = None,
-        slowMo: int = None,
+        slowMo: float = None,
+        tracesDir: Union[pathlib.Path, str] = None,
+        artifactsDir: Union[pathlib.Path, str] = None,
         chromiumSandbox: bool = None,
-        firefoxUserPrefs: Dict[str, Union[str, int, bool]] = None,
+        firefoxUserPrefs: Dict[str, Union[str, float, bool]] = None,
     ) -> Browser:
         params = locals_to_params(locals())
         normalize_launch_params(params)
-        try:
-            return from_channel(await self._channel.send("launch", params))
-        except Exception as e:
-            if f"{self.name}-" in str(e):
-                raise not_installed_error(f'"{self.name}" browser was not found.')
-            raise e
-
-    async def launchPersistentContext(
+        browser = cast(
+            Browser,
+            from_channel(
+                await self._channel.send(
+                    "launch", TimeoutSettings.launch_timeout, params
+                )
+            ),
+        )
+        browser._connect_to_browser_type(
+            self, str(tracesDir) if tracesDir is not None else None
+        )
+        return browser
+
+    async def launch_persistent_context(
         self,
         userDataDir: Union[str, Path],
+        channel: str = None,
         executablePath: Union[str, Path] = None,
-        args: List[str] = None,
-        ignoreDefaultArgs: Union[bool, List[str]] = None,
+        args: Sequence[str] = None,
+        ignoreDefaultArgs: Union[bool, Sequence[str]] = None,
         handleSIGINT: bool = None,
         handleSIGTERM: bool = None,
         handleSIGHUP: bool = None,
-        timeout: int = None,
+        timeout: float = None,
         env: Env = None,
         headless: bool = None,
-        devtools: bool = None,
         proxy: ProxySettings = None,
         downloadsPath: Union[str, Path] = None,
-        slowMo: int = None,
-        viewport: Union[Tuple[int, int], Literal[0]] = None,
+        slowMo: float = None,
+        viewport: ViewportSize = None,
+        screen: ViewportSize = None,
+        noViewport: bool = None,
         ignoreHTTPSErrors: bool = None,
         javaScriptEnabled: bool = None,
         bypassCSP: bool = None,
@@ -98,45 +131,240 @@ async def launchPersistentContext(
         locale: str = None,
         timezoneId: str = None,
         geolocation: Geolocation = None,
-        permissions: List[str] = None,
+        permissions: Sequence[str] = None,
         extraHTTPHeaders: Dict[str, str] = None,
         offline: bool = None,
-        httpCredentials: Tuple[str, str] = None,
-        deviceScaleFactor: int = None,
+        httpCredentials: HttpCredentials = None,
+        deviceScaleFactor: float = None,
         isMobile: bool = None,
         hasTouch: bool = None,
         colorScheme: ColorScheme = None,
+        reducedMotion: ReducedMotion = None,
+        forcedColors: ForcedColors = None,
+        contrast: Contrast = None,
         acceptDownloads: bool = None,
+        tracesDir: Union[pathlib.Path, str] = None,
+        artifactsDir: Union[pathlib.Path, str] = None,
         chromiumSandbox: bool = None,
+        firefoxUserPrefs: Dict[str, Union[str, float, bool]] = None,
         recordHarPath: Union[Path, str] = None,
         recordHarOmitContent: bool = None,
         recordVideoDir: Union[Path, str] = None,
-        recordVideoSize: Tuple[int, int] = None,
+        recordVideoSize: ViewportSize = None,
+        baseURL: str = None,
+        strictSelectors: bool = None,
+        serviceWorkers: ServiceWorkersPolicy = None,
+        recordHarUrlFilter: Union[Pattern[str], str] = None,
+        recordHarMode: HarMode = None,
+        recordHarContent: HarContentPolicy = None,
+        clientCertificates: List[ClientCertificate] = None,
     ) -> BrowserContext:
-        userDataDir = str(Path(userDataDir))
+        userDataDir = self._user_data_dir(userDataDir)
         params = locals_to_params(locals())
-        normalize_context_params(params)
+        await self._prepare_browser_context_params(params)
         normalize_launch_params(params)
-        try:
-            context = from_channel(
-                await self._channel.send("launchPersistentContext", params)
+        result = await self._channel.send_return_as_dict(
+            "launchPersistentContext", TimeoutSettings.launch_timeout, params
+        )
+        browser = cast(
+            Browser,
+            from_channel(result["browser"]),
+        )
+        browser._connect_to_browser_type(
+            self, str(tracesDir) if tracesDir is not None else None
+        )
+        context = cast(BrowserContext, from_channel(result["context"]))
+        await context._initialize_har_from_options(
+            record_har_content=recordHarContent,
+            record_har_mode=recordHarMode,
+            record_har_omit_content=recordHarOmitContent,
+            record_har_path=recordHarPath,
+            record_har_url_filter=recordHarUrlFilter,
+        )
+        return context
+
+    def _user_data_dir(self, userDataDir: Optional[Union[str, Path]]) -> str:
+        if not userDataDir:
+            return ""
+        if not Path(userDataDir).is_absolute():
+            # Can be dropped once we drop Python 3.9 support (10/2025):
+            # https://github.com/python/cpython/issues/82852
+            if sys.platform == "win32" and sys.version_info[:2] < (3, 10):
+                return str(pathlib.Path.cwd() / userDataDir)
+            return str(Path(userDataDir).resolve())
+        return str(Path(userDataDir))
+
+    async def connect_over_cdp(
+        self,
+        endpointURL: str,
+        timeout: float = None,
+        slowMo: float = None,
+        headers: Dict[str, str] = None,
+        isLocal: bool = None,
+        noDefaults: bool = None,
+    ) -> Browser:
+        params = locals_to_params(locals())
+        if params.get("headers"):
+            params["headers"] = serialize_headers(params["headers"])
+        response = await self._channel.send_return_as_dict(
+            "connectOverCDP", TimeoutSettings.launch_timeout, params
+        )
+        browser = cast(Browser, from_channel(response["browser"]))
+        browser._connect_to_browser_type(self, None)
+
+        return browser
+
+    async def connect(
+        self,
+        endpoint: str,
+        timeout: float = None,
+        slowMo: float = None,
+        headers: Dict[str, str] = None,
+        exposeNetwork: str = None,
+    ) -> Browser:
+        if slowMo is None:
+            slowMo = 0
+
+        headers = {**(headers if headers else {}), "x-playwright-browser": self.name}
+        local_utils = self._connection.local_utils
+        pipe_channel = (
+            await local_utils._channel.send_return_as_dict(
+                "connect",
+                None,
+                {
+                    "endpoint": endpoint,
+                    "headers": headers,
+                    "slowMo": slowMo,
+                    "timeout": timeout if timeout is not None else 0,
+                    "exposeNetwork": exposeNetwork,
+                },
             )
-            context._options = params
-            return context
-        except Exception as e:
-            if f"{self.name}-" in str(e):
-                raise not_installed_error(f'"{self.name}" browser was not found.')
-            raise e
+        )["pipe"]
+        transport = JsonPipeTransport(self._connection._loop, pipe_channel)
+
+        connection = Connection(
+            self._connection._dispatcher_fiber,
+            self._connection._object_factory,
+            transport,
+            self._connection._loop,
+            local_utils=self._connection.local_utils,
+        )
+        connection.mark_as_remote()
+
+        browser = None
+
+        def handle_transport_close(reason: Optional[str]) -> None:
+            if browser:
+                for context in browser.contexts:
+                    for page in context.pages:
+                        page._on_close()
+                    context._on_close()
+                browser._on_close()
+            connection.cleanup(reason)
+            # TODO: Backport https://github.com/microsoft/playwright/commit/d8d5289e8692c9b1265d23ee66988d1ac5122f33
+            # Give a chance to any API call promises to reject upon page/context closure.
+            # This happens naturally when we receive page.onClose and browser.onClose from the server
+            # in separate tasks. However, upon pipe closure we used to dispatch them all synchronously
+            # here and promises did not have a chance to reject.
+            # The order of rejects vs closure is a part of the API contract and our test runner
+            # relies on it to attribute rejections to the right test.
+
+        transport.once("close", handle_transport_close)
+
+        connection._is_sync = self._connection._is_sync
+        connection._loop.create_task(connection.run())
+        playwright_future = connection.playwright_future
+
+        timeout_future = throw_on_timeout(
+            timeout if timeout is not None else PLAYWRIGHT_MAX_DEADLINE,
+            Error("Connection timed out"),
+        )
+        done, pending = await asyncio.wait(
+            {transport.on_error_future, playwright_future, timeout_future},
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        if not playwright_future.done():
+            playwright_future.cancel()
+        if not timeout_future.done():
+            timeout_future.cancel()
+        playwright: "Playwright" = next(iter(done)).result()
+        playwright._set_selectors(self._playwright.selectors)
+        self._connection._child_ws_connections.append(connection)
+        pre_launched_browser = playwright._initializer.get("preLaunchedBrowser")
+        assert pre_launched_browser
+        browser = cast(Browser, from_channel(pre_launched_browser))
+        browser._should_close_connection_on_close = True
+        browser._connect_to_browser_type(self, None)
+
+        return browser
+
+    async def _prepare_browser_context_params(self, params: Dict) -> None:
+        if params.get("noViewport"):
+            del params["noViewport"]
+            params["noDefaultViewport"] = True
+        if "defaultBrowserType" in params:
+            del params["defaultBrowserType"]
+        if "extraHTTPHeaders" in params:
+            params["extraHTTPHeaders"] = serialize_headers(params["extraHTTPHeaders"])
+        if "recordVideoDir" in params:
+            params["recordVideo"] = {"dir": Path(params["recordVideoDir"]).absolute()}
+            if "recordVideoSize" in params:
+                params["recordVideo"]["size"] = params["recordVideoSize"]
+                del params["recordVideoSize"]
+            del params["recordVideoDir"]
+        if "storageState" in params:
+            storageState = params["storageState"]
+            if not isinstance(storageState, dict):
+                params["storageState"] = json.loads(
+                    (await async_readfile(storageState)).decode()
+                )
+        if params.get("colorScheme", None) == "null":
+            params["colorScheme"] = "no-override"
+        if params.get("reducedMotion", None) == "null":
+            params["reducedMotion"] = "no-override"
+        if params.get("forcedColors", None) == "null":
+            params["forcedColors"] = "no-override"
+        if params.get("contrast", None) == "null":
+            params["contrast"] = "no-override"
+        if "acceptDownloads" in params:
+            params["acceptDownloads"] = (
+                "accept" if params["acceptDownloads"] else "deny"
+            )
+
+        if "clientCertificates" in params:
+            params["clientCertificates"] = await to_client_certificates_protocol(
+                params["clientCertificates"]
+            )
+        params["selectorEngines"] = self._playwright.selectors._selector_engines
+        params["testIdAttributeName"] = (
+            self._playwright.selectors._test_id_attribute_name
+        )
+
+        # Remove HAR options
+        params.pop("recordHarPath", None)
+        params.pop("recordHarOmitContent", None)
+        params.pop("recordHarUrlFilter", None)
+        params.pop("recordHarMode", None)
+        params.pop("recordHarContent", None)
 
 
 def normalize_launch_params(params: Dict) -> None:
     if "env" in params:
-        params["env"] = {name: str(value) for [name, value] in params["env"].items()}
+        params["env"] = [
+            {"name": name, "value": str(value)}
+            for [name, value] in params["env"].items()
+        ]
     if "ignoreDefaultArgs" in params:
         if params["ignoreDefaultArgs"] is True:
             params["ignoreAllDefaultArgs"] = True
             del params["ignoreDefaultArgs"]
+        elif params["ignoreDefaultArgs"] is False:
+            del params["ignoreDefaultArgs"]
     if "executablePath" in params:
         params["executablePath"] = str(Path(params["executablePath"]))
     if "downloadsPath" in params:
         params["downloadsPath"] = str(Path(params["downloadsPath"]))
+    if "tracesDir" in params:
+        params["tracesDir"] = str(Path(params["tracesDir"]))
+    if "artifactsDir" in params:
+        params["artifactsDir"] = str(Path(params["artifactsDir"]))
diff --git a/playwright/_impl/_cdp_session.py b/playwright/_impl/_cdp_session.py
index 3e78ad89d..07d291ae2 100644
--- a/playwright/_impl/_cdp_session.py
+++ b/playwright/_impl/_cdp_session.py
@@ -12,26 +12,35 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from types import SimpleNamespace
 from typing import Any, Dict
 
 from playwright._impl._connection import ChannelOwner
 from playwright._impl._helper import locals_to_params
-from playwright._impl._js_handle import parse_result
 
 
 class CDPSession(ChannelOwner):
+    Events = SimpleNamespace(
+        Event="event",
+        Close="close",
+    )
+
     def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
         self._channel.on("event", lambda params: self._on_event(params))
+        self._channel.on("close", lambda _: self.emit(CDPSession.Events.Close, self))
 
     def _on_event(self, params: Any) -> None:
-        self.emit(params["method"], parse_result(params["params"]))
+        self.emit(params["method"], params.get("params"))
+        self.emit(CDPSession.Events.Event, params)
 
     async def send(self, method: str, params: Dict = None) -> Dict:
-        result = await self._channel.send("send", locals_to_params(locals()))
-        return parse_result(result)
+        return await self._channel.send("send", None, locals_to_params(locals()))
 
     async def detach(self) -> None:
-        await self._channel.send("detach")
+        await self._channel.send(
+            "detach",
+            None,
+        )
diff --git a/playwright/_impl/_chromium_browser_context.py b/playwright/_impl/_chromium_browser_context.py
deleted file mode 100644
index e25efb2ab..000000000
--- a/playwright/_impl/_chromium_browser_context.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# 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.
-
-from types import SimpleNamespace
-from typing import Dict, List, Set
-
-from playwright._impl._browser_context import BrowserContext
-from playwright._impl._cdp_session import CDPSession
-from playwright._impl._connection import ChannelOwner, from_channel
-from playwright._impl._page import Page, Worker
-
-
-class ChromiumBrowserContext(BrowserContext):
-
-    Events = SimpleNamespace(
-        BackgroundPage="backgroundpage",
-        ServiceWorker="serviceworker",
-    )
-
-    def __init__(
-        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
-    ) -> None:
-        super().__init__(parent, type, guid, initializer)
-
-        self._background_pages: Set[Page] = set()
-        self._service_workers: Set[Worker] = set()
-
-        self._channel.on(
-            "crBackgroundPage",
-            lambda params: self._on_background_page(from_channel(params["page"])),
-        )
-
-        self._channel.on(
-            "crServiceWorker",
-            lambda params: self._on_service_worker(from_channel(params["worker"])),
-        )
-
-    def _on_background_page(self, page: Page) -> None:
-        self._background_pages.add(page)
-        self.emit(ChromiumBrowserContext.Events.BackgroundPage, page)
-
-    def _on_service_worker(self, worker: Worker) -> None:
-        worker._context = self
-        self._service_workers.add(worker)
-        self.emit(ChromiumBrowserContext.Events.ServiceWorker, worker)
-
-    def backgroundPages(self) -> List[Page]:
-        return list(self._background_pages)
-
-    def serviceWorkers(self) -> List[Worker]:
-        return list(self._service_workers)
-
-    async def newCDPSession(self, page: Page) -> CDPSession:
-        return from_channel(
-            await self._channel.send("crNewCDPSession", {"page": page._channel})
-        )
diff --git a/playwright/_impl/_clock.py b/playwright/_impl/_clock.py
new file mode 100644
index 000000000..f6eb7c42d
--- /dev/null
+++ b/playwright/_impl/_clock.py
@@ -0,0 +1,104 @@
+# 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 datetime
+from typing import TYPE_CHECKING, Dict, Union
+
+if TYPE_CHECKING:
+    from playwright._impl._browser_context import BrowserContext
+
+
+class Clock:
+    def __init__(self, browser_context: "BrowserContext") -> None:
+        self._browser_context = browser_context
+        self._loop = browser_context._loop
+        self._dispatcher_fiber = browser_context._dispatcher_fiber
+
+    async def install(self, time: Union[float, str, datetime.datetime] = None) -> None:
+        await self._browser_context._channel.send(
+            "clockInstall",
+            None,
+            parse_time(time) if time is not None else {},
+        )
+
+    async def fast_forward(
+        self,
+        ticks: Union[int, str],
+    ) -> None:
+        await self._browser_context._channel.send(
+            "clockFastForward",
+            None,
+            parse_ticks(ticks),
+        )
+
+    async def pause_at(
+        self,
+        time: Union[float, str, datetime.datetime],
+    ) -> None:
+        await self._browser_context._channel.send(
+            "clockPauseAt",
+            None,
+            parse_time(time),
+        )
+
+    async def resume(
+        self,
+    ) -> None:
+        await self._browser_context._channel.send("clockResume", None)
+
+    async def run_for(
+        self,
+        ticks: Union[int, str],
+    ) -> None:
+        await self._browser_context._channel.send(
+            "clockRunFor",
+            None,
+            parse_ticks(ticks),
+        )
+
+    async def set_fixed_time(
+        self,
+        time: Union[float, str, datetime.datetime],
+    ) -> None:
+        await self._browser_context._channel.send(
+            "clockSetFixedTime",
+            None,
+            parse_time(time),
+        )
+
+    async def set_system_time(
+        self,
+        time: Union[float, str, datetime.datetime],
+    ) -> None:
+        await self._browser_context._channel.send(
+            "clockSetSystemTime",
+            None,
+            parse_time(time),
+        )
+
+
+def parse_time(
+    time: Union[float, str, datetime.datetime],
+) -> Dict[str, Union[int, str]]:
+    if isinstance(time, (float, int)):
+        return {"timeNumber": int(time * 1_000)}
+    if isinstance(time, str):
+        return {"timeString": time}
+    return {"timeNumber": int(time.timestamp() * 1_000)}
+
+
+def parse_ticks(ticks: Union[int, str]) -> Dict[str, Union[int, str]]:
+    if isinstance(ticks, int):
+        return {"ticksNumber": ticks}
+    return {"ticksString": ticks}
diff --git a/playwright/_impl/_connection.py b/playwright/_impl/_connection.py
index 0d091f6ec..bbc42b6e1 100644
--- a/playwright/_impl/_connection.py
+++ b/playwright/_impl/_connection.py
@@ -13,39 +13,123 @@
 # limitations under the License.
 
 import asyncio
+import collections.abc
+import contextvars
+import datetime
+import inspect
 import sys
 import traceback
 from pathlib import Path
-from typing import Any, Callable, Dict, Optional, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    TypedDict,
+    Union,
+    cast,
+)
+
+from pyee import EventEmitter
+from pyee.asyncio import AsyncIOEventEmitter
+
+import playwright
+import playwright._impl._impl_to_api_mapping
+from playwright._impl._errors import TargetClosedError, rewrite_error
+from playwright._impl._greenlets import EventGreenlet
+from playwright._impl._helper import Error, ParsedMessagePayload, parse_error
+from playwright._impl._transport import Transport
 
-from greenlet import greenlet
-from pyee import AsyncIOEventEmitter
+if TYPE_CHECKING:
+    from playwright._impl._local_utils import LocalUtils
+    from playwright._impl._playwright import Playwright
 
-from playwright._impl._api_types import ApiType
-from playwright._impl._helper import ParsedMessagePayload, parse_error
-from playwright._impl._transport import Transport
+TimeoutCalculator = Optional[Callable[[Optional[float]], float]]
 
 
 class Channel(AsyncIOEventEmitter):
-    def __init__(self, connection: "Connection", guid: str) -> None:
+    def __init__(self, connection: "Connection", object: "ChannelOwner") -> None:
         super().__init__()
-        self._connection: Connection = connection
-        self._guid = guid
-        self._object: Optional[ChannelOwner] = None
+        self._connection = connection
+        self._guid = object._guid
+        self._object = object
+        self.on("error", lambda exc: self._connection._on_event_listener_error(exc))
+
+    async def send(
+        self,
+        method: str,
+        timeout_calculator: TimeoutCalculator,
+        params: Dict = None,
+        is_internal: bool = False,
+        title: str = None,
+    ) -> Any:
+        return await self._connection.wrap_api_call(
+            lambda: self._inner_send(method, timeout_calculator, params, False),
+            is_internal,
+            title,
+        )
 
-    async def send(self, method: str, params: Dict = None) -> Any:
-        return await self.inner_send(method, params, False)
+    async def send_return_as_dict(
+        self,
+        method: str,
+        timeout_calculator: TimeoutCalculator,
+        params: Dict = None,
+        is_internal: bool = False,
+        title: str = None,
+    ) -> Any:
+        return await self._connection.wrap_api_call(
+            lambda: self._inner_send(method, timeout_calculator, params, True),
+            is_internal,
+            title,
+        )
 
-    async def send_return_as_dict(self, method: str, params: Dict = None) -> Any:
-        return await self.inner_send(method, params, True)
+    def send_no_reply(
+        self,
+        method: str,
+        timeout_calculator: TimeoutCalculator,
+        params: Dict = None,
+        is_internal: bool = False,
+        title: str = None,
+    ) -> None:
+        # No reply messages are used to e.g. waitForEventInfo(after).
+        self._connection.wrap_api_call_sync(
+            lambda: self._connection._send_message_to_server(
+                self._object,
+                method,
+                _augment_params(params, timeout_calculator),
+                True,
+            ),
+            is_internal,
+            title,
+        )
 
-    async def inner_send(
-        self, method: str, params: Optional[Dict], return_as_dict: bool
+    async def _inner_send(
+        self,
+        method: str,
+        timeout_calculator: TimeoutCalculator,
+        params: Optional[Dict],
+        return_as_dict: bool,
     ) -> Any:
-        if params is None:
-            params = {}
-        callback = self._connection._send_message_to_server(self._guid, method, params)
-        result = await callback.future
+        if self._connection._error:
+            error = self._connection._error
+            self._connection._error = None
+            raise error
+        callback = self._connection._send_message_to_server(
+            self._object, method, _augment_params(params, timeout_calculator)
+        )
+        done, _ = await asyncio.wait(
+            {
+                self._connection._transport.on_error_future,
+                callback.future,
+            },
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        if not callback.future.done():
+            callback.future.cancel()
+        result = next(iter(done)).result()
         # Protocol now has named return values, assume result is one level deeper unless
         # there is explicit ambiguity.
         if not result:
@@ -59,11 +143,6 @@ async def inner_send(
         key = next(iter(result))
         return result[key]
 
-    def send_no_reply(self, method: str, params: Dict = None) -> None:
-        if params is None:
-            params = {}
-        self._connection._send_message_to_server(self._guid, method, params)
-
 
 class ChannelOwner(AsyncIOEventEmitter):
     def __init__(
@@ -77,7 +156,7 @@ def __init__(
         self._loop: asyncio.AbstractEventLoop = parent._loop
         self._dispatcher_fiber: Any = parent._dispatcher_fiber
         self._type = type
-        self._guid = guid
+        self._guid: str = guid
         self._connection: Connection = (
             parent._connection if isinstance(parent, ChannelOwner) else parent
         )
@@ -85,50 +164,139 @@ def __init__(
             parent if isinstance(parent, ChannelOwner) else None
         )
         self._objects: Dict[str, "ChannelOwner"] = {}
-        self._channel = Channel(self._connection, guid)
-        self._channel._object = self
+        self._channel: Channel = Channel(self._connection, self)
         self._initializer = initializer
+        self._was_collected = False
 
         self._connection._objects[guid] = self
         if self._parent:
             self._parent._objects[guid] = self
 
-    def _dispose(self) -> None:
+        self._event_to_subscription_mapping: Dict[str, str] = {}
+
+    def _dispose(self, reason: Optional[str]) -> None:
         # Clean up from parent and connection.
         if self._parent:
             del self._parent._objects[self._guid]
         del self._connection._objects[self._guid]
+        self._was_collected = reason == "gc"
 
         # Dispose all children.
         for object in list(self._objects.values()):
-            object._dispose()
+            object._dispose(reason)
         self._objects.clear()
 
+    def _adopt(self, child: "ChannelOwner") -> None:
+        del cast("ChannelOwner", child._parent)._objects[child._guid]
+        self._objects[child._guid] = child
+        child._parent = self
+
+    def _set_event_to_subscription_mapping(self, mapping: Dict[str, str]) -> None:
+        self._event_to_subscription_mapping = mapping
+
+    def _update_subscription(self, event: str, enabled: bool) -> None:
+        protocol_event = self._event_to_subscription_mapping.get(event)
+        if protocol_event:
+            self._connection.wrap_api_call_sync(
+                lambda: self._channel.send_no_reply(
+                    "updateSubscription",
+                    None,
+                    {"event": protocol_event, "enabled": enabled},
+                ),
+                True,
+            )
+
+    def _add_event_handler(self, event: str, k: Any, v: Any) -> None:
+        if not self.listeners(event):
+            self._update_subscription(event, True)
+        super()._add_event_handler(event, k, v)
+
+    def remove_listener(self, event: str, f: Any) -> None:
+        super().remove_listener(event, f)
+        if not self.listeners(event):
+            self._update_subscription(event, False)
+
 
 class ProtocolCallback:
-    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
-        self.stack_trace = "".join(traceback.format_stack()[-10:])
+    def __init__(self, loop: asyncio.AbstractEventLoop, no_reply: bool = False) -> None:
+        self.stack_trace: traceback.StackSummary
+        self.no_reply = no_reply
         self.future = loop.create_future()
+        if no_reply:
+            self.future.set_result(None)
+        # The outer task can get cancelled by the user, this forwards the cancellation to the inner task.
+        current_task = asyncio.current_task()
+
+        def cb(task: asyncio.Task) -> None:
+            if current_task:
+                current_task.remove_done_callback(cb)
+            if task.cancelled():
+                self.future.cancel()
+
+        if current_task:
+            current_task.add_done_callback(cb)
+            self.future.add_done_callback(
+                lambda _: (
+                    current_task.remove_done_callback(cb) if current_task else None
+                )
+            )
 
 
 class RootChannelOwner(ChannelOwner):
     def __init__(self, connection: "Connection") -> None:
-        super().__init__(connection, "", "", {})
+        super().__init__(connection, "Root", "", {})
+
+    async def initialize(self) -> "Playwright":
+        return from_channel(
+            await self._channel.send(
+                "initialize",
+                None,
+                {
+                    "sdkLanguage": "python",
+                },
+            )
+        )
 
 
-class Connection:
+class Connection(EventEmitter):
     def __init__(
-        self, dispatcher_fiber: Any, object_factory: Any, driver_executable: Path
+        self,
+        dispatcher_fiber: Any,
+        object_factory: Callable[[ChannelOwner, str, str, Dict], ChannelOwner],
+        transport: Transport,
+        loop: asyncio.AbstractEventLoop,
+        local_utils: Optional["LocalUtils"] = None,
     ) -> None:
-        self._dispatcher_fiber: Any = dispatcher_fiber
-        self._transport = Transport(driver_executable)
-        self._transport.on_message = lambda msg: self._dispatch(msg)
-        self._waiting_for_object: Dict[str, Any] = {}
+        super().__init__()
+        self._dispatcher_fiber = dispatcher_fiber
+        self._transport = transport
+        self._transport.on_message = lambda msg: self.dispatch(msg)
+        self._waiting_for_object: Dict[str, Callable[[ChannelOwner], None]] = {}
         self._last_id = 0
         self._objects: Dict[str, ChannelOwner] = {}
         self._callbacks: Dict[int, ProtocolCallback] = {}
         self._object_factory = object_factory
         self._is_sync = False
+        self._child_ws_connections: List["Connection"] = []
+        self._loop = loop
+        self.playwright_future: asyncio.Future["Playwright"] = loop.create_future()
+        self._error: Optional[BaseException] = None
+        self.is_remote = False
+        self._init_task: Optional[asyncio.Task] = None
+        self._api_zone: contextvars.ContextVar[Optional[ParsedStackTrace]] = (
+            contextvars.ContextVar("ApiZone", default=None)
+        )
+        self._local_utils: Optional["LocalUtils"] = local_utils
+        self._tracing_count = 0
+        self._closed_error: Optional[Exception] = None
+
+    @property
+    def local_utils(self) -> "LocalUtils":
+        assert self._local_utils
+        return self._local_utils
+
+    def mark_as_remote(self) -> None:
+        self.is_remote = True
 
     async def run_as_sync(self) -> None:
         self._is_sync = True
@@ -137,55 +305,124 @@ async def run_as_sync(self) -> None:
     async def run(self) -> None:
         self._loop = asyncio.get_running_loop()
         self._root_object = RootChannelOwner(self)
+
+        async def init() -> None:
+            self.playwright_future.set_result(await self._root_object.initialize())
+
+        await self._transport.connect()
+        self._init_task = self._loop.create_task(init())
         await self._transport.run()
 
     def stop_sync(self) -> None:
-        self._transport.stop()
+        self._transport.request_stop()
         self._dispatcher_fiber.switch()
-
-    def stop_async(self) -> None:
-        self._transport.stop()
-
-    async def wait_for_object_with_known_name(self, guid: str) -> Any:
-        if guid in self._objects:
-            return self._objects[guid]
-        callback = self._loop.create_future()
-
-        def callback_wrapper(result: Any) -> None:
-            callback.set_result(result)
-
-        self._waiting_for_object[guid] = callback_wrapper
-        return await callback
+        self._loop.run_until_complete(self._transport.wait_until_stopped())
+        self.cleanup()
+
+    async def stop_async(self) -> None:
+        self._transport.request_stop()
+        await self._transport.wait_until_stopped()
+        self.cleanup()
+
+    def cleanup(self, cause: str = None) -> None:
+        self._closed_error = TargetClosedError(cause) if cause else TargetClosedError()
+        if self._init_task and not self._init_task.done():
+            self._init_task.cancel()
+        for ws_connection in self._child_ws_connections:
+            ws_connection._transport.dispose()
+        for callback in self._callbacks.values():
+            # To prevent 'Future exception was never retrieved' we ignore all callbacks that are no_reply.
+            if callback.no_reply:
+                continue
+            if callback.future.cancelled():
+                continue
+            callback.future.set_exception(self._closed_error)
+        self._callbacks.clear()
+        self.emit("close")
 
     def call_on_object_with_known_name(
-        self, guid: str, callback: Callable[[Any], None]
+        self, guid: str, callback: Callable[[ChannelOwner], None]
     ) -> None:
         self._waiting_for_object[guid] = callback
 
+    def set_is_tracing(self, is_tracing: bool) -> None:
+        if is_tracing:
+            self._tracing_count += 1
+        else:
+            self._tracing_count -= 1
+
     def _send_message_to_server(
-        self, guid: str, method: str, params: Dict
+        self, object: ChannelOwner, method: str, params: Dict, no_reply: bool = False
     ) -> ProtocolCallback:
+        if self._closed_error:
+            raise self._closed_error
+        if object._was_collected:
+            raise Error(
+                "The object has been collected to prevent unbounded heap growth."
+            )
         self._last_id += 1
         id = self._last_id
-        message = dict(
-            id=id,
-            guid=guid,
-            method=method,
-            params=self._replace_channels_with_guids(params, "params"),
+        callback = ProtocolCallback(self._loop, no_reply=no_reply)
+        task = asyncio.current_task(self._loop)
+        callback.stack_trace = cast(
+            traceback.StackSummary,
+            getattr(task, "__pw_stack_trace__", traceback.extract_stack(limit=10)),
         )
-        self._transport.send(message)
-        callback = ProtocolCallback(self._loop)
+        callback.no_reply = no_reply
+        stack_trace_information = cast(ParsedStackTrace, self._api_zone.get())
+        frames = stack_trace_information.get("frames", [])
+        location = (
+            {
+                "file": frames[0]["file"],
+                "line": frames[0]["line"],
+                "column": frames[0]["column"],
+            }
+            if frames
+            else None
+        )
+        metadata = {
+            "wallTime": int(datetime.datetime.now().timestamp() * 1000),
+            "apiName": stack_trace_information["apiName"],
+            "internal": not stack_trace_information["apiName"],
+        }
+        if location:
+            metadata["location"] = location  # type: ignore
+        title = stack_trace_information["title"]
+        if title:
+            metadata["title"] = title
+        message = {
+            "id": id,
+            "guid": object._guid,
+            "method": method,
+            "params": self._replace_channels_with_guids(params),
+            "metadata": metadata,
+        }
+        if self._tracing_count > 0 and frames and object._guid != "localUtils":
+            self.local_utils.add_stack_to_tracing_no_reply(id, frames)
+
         self._callbacks[id] = callback
+        self._transport.send(message)
+
         return callback
 
-    def _dispatch(self, msg: ParsedMessagePayload) -> None:
+    def dispatch(self, msg: ParsedMessagePayload) -> None:
+        if self._closed_error:
+            return
         id = msg.get("id")
         if id:
             callback = self._callbacks.pop(id)
+            if callback.future.cancelled():
+                return
+            # No reply messages are used to e.g. waitForEventInfo(after) which returns exceptions on page close.
+            # To prevent 'Future exception was never retrieved' we just ignore such messages.
+            if callback.no_reply:
+                return
             error = msg.get("error")
-            if error:
-                parsed_error = parse_error(error["error"])  # type: ignore
-                parsed_error.stack = callback.stack_trace
+            if error and not msg.get("result"):
+                parsed_error = parse_error(
+                    error["error"], format_call_log(msg.get("log"))  # type: ignore
+                )
+                parsed_error._stack = "".join(callback.stack_trace.format())
                 callback.future.set_exception(parsed_error)
             else:
                 result = self._replace_guids_with_channels(msg.get("result"))
@@ -193,66 +430,100 @@ def _dispatch(self, msg: ParsedMessagePayload) -> None:
             return
 
         guid = msg["guid"]
-        method = msg.get("method")
-        params = msg["params"]
+        method = msg["method"]
+        params = msg.get("params")
         if method == "__create__":
+            assert params
             parent = self._objects[guid]
             self._create_remote_object(
                 parent, params["type"], params["guid"], params["initializer"]
             )
             return
-        if method == "__dispose__":
-            self._objects[guid]._dispose()
+
+        object = self._objects.get(guid)
+        if not object:
+            raise Exception(f'Cannot find object to "{method}": {guid}')
+
+        if method == "__adopt__":
+            child_guid = cast(Dict[str, str], params)["guid"]
+            child = self._objects.get(child_guid)
+            if not child:
+                raise Exception(f"Unknown new child: {child_guid}")
+            object._adopt(child)
             return
 
+        if method == "__dispose__":
+            assert isinstance(params, dict)
+            self._objects[guid]._dispose(cast(Optional[str], params.get("reason")))
+            return
         object = self._objects[guid]
+        should_replace_guids_with_channels = "jsonPipe@" not in guid
         try:
             if self._is_sync:
                 for listener in object._channel.listeners(method):
-                    g = greenlet(listener)
-                    g.switch(self._replace_guids_with_channels(params))
+                    # Event handlers like route/locatorHandlerTriggered require us to perform async work.
+                    # In order to report their potential errors to the user, we need to catch it and store it in the connection
+                    def _done_callback(future: asyncio.Future) -> None:
+                        exc = future.exception()
+                        if exc:
+                            self._on_event_listener_error(exc)
+
+                    def _listener_with_error_handler_attached(params: Any) -> None:
+                        potential_future = listener(params)
+                        if asyncio.isfuture(potential_future):
+                            potential_future.add_done_callback(_done_callback)
+
+                    # Each event handler is a potentilly blocking context, create a fiber for each
+                    # and switch to them in order, until they block inside and pass control to each
+                    # other and then eventually back to dispatcher as listener functions return.
+                    g = EventGreenlet(_listener_with_error_handler_attached)
+                    if should_replace_guids_with_channels:
+                        g.switch(self._replace_guids_with_channels(params))
+                    else:
+                        g.switch(params)
             else:
-                object._channel.emit(method, self._replace_guids_with_channels(params))
-        except Exception:
-            print(
-                "Error dispatching the event",
-                "".join(traceback.format_exception(*sys.exc_info())),
-            )
+                if should_replace_guids_with_channels:
+                    object._channel.emit(
+                        method, self._replace_guids_with_channels(params)
+                    )
+                else:
+                    object._channel.emit(method, params)
+        except BaseException as exc:
+            self._on_event_listener_error(exc)
+
+    def _on_event_listener_error(self, exc: BaseException) -> None:
+        print("Error occurred in event listener", file=sys.stderr)
+        traceback.print_exception(type(exc), exc, exc.__traceback__, file=sys.stderr)
+        # Save the error to throw at the next API call. This "replicates" unhandled rejection in Node.js.
+        self._error = exc
 
     def _create_remote_object(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
-    ) -> Any:
-        result: ChannelOwner
+    ) -> ChannelOwner:
         initializer = self._replace_guids_with_channels(initializer)
         result = self._object_factory(parent, type, guid, initializer)
         if guid in self._waiting_for_object:
             self._waiting_for_object.pop(guid)(result)
         return result
 
-    def _replace_channels_with_guids(self, payload: Any, param_name: str) -> Any:
+    def _replace_channels_with_guids(
+        self,
+        payload: Any,
+    ) -> Any:
         if payload is None:
             return payload
-        if isinstance(payload, tuple):
-            if param_name == "position":
-                return {"x": payload[0], "y": payload[1]}
-            if param_name == "size" or param_name == "viewport":
-                return {"width": payload[0], "height": payload[1]}
-            if param_name == "httpCredentials":
-                return {"username": payload[0], "password": payload[1]}
         if isinstance(payload, Path):
             return str(payload)
-        if isinstance(payload, ApiType):
-            return payload._to_json()
-        if isinstance(payload, list):
-            return list(
-                map(lambda p: self._replace_channels_with_guids(p, "index"), payload)
-            )
+        if isinstance(payload, collections.abc.Sequence) and not isinstance(
+            payload, str
+        ):
+            return list(map(self._replace_channels_with_guids, payload))
         if isinstance(payload, Channel):
             return dict(guid=payload._guid)
         if isinstance(payload, dict):
             result = {}
-            for key in payload:
-                result[key] = self._replace_channels_with_guids(payload[key], key)
+            for key, value in payload.items():
+                result[key] = self._replace_channels_with_guids(value)
             return result
         return payload
 
@@ -260,16 +531,53 @@ def _replace_guids_with_channels(self, payload: Any) -> Any:
         if payload is None:
             return payload
         if isinstance(payload, list):
-            return list(map(lambda p: self._replace_guids_with_channels(p), payload))
+            return list(map(self._replace_guids_with_channels, payload))
         if isinstance(payload, dict):
             if payload.get("guid") in self._objects:
                 return self._objects[payload["guid"]]._channel
             result = {}
-            for key in payload:
-                result[key] = self._replace_guids_with_channels(payload[key])
+            for key, value in payload.items():
+                result[key] = self._replace_guids_with_channels(value)
             return result
         return payload
 
+    async def wrap_api_call(
+        self, cb: Callable[[], Any], is_internal: bool = False, title: str = None
+    ) -> Any:
+        if self._api_zone.get():
+            return await cb()
+        task = asyncio.current_task(self._loop)
+        st: List[inspect.FrameInfo] = getattr(
+            task, "__pw_stack__", None
+        ) or inspect.stack(0)
+
+        parsed_st = _extract_stack_trace_information_from_stack(st, is_internal, title)
+        self._api_zone.set(parsed_st)
+        try:
+            return await cb()
+        except Exception as error:
+            raise rewrite_error(error, f"{parsed_st['apiName']}: {error}") from None
+        finally:
+            self._api_zone.set(None)
+
+    def wrap_api_call_sync(
+        self, cb: Callable[[], Any], is_internal: bool = False, title: str = None
+    ) -> Any:
+        if self._api_zone.get():
+            return cb()
+        task = asyncio.current_task(self._loop)
+        st: List[inspect.FrameInfo] = getattr(
+            task, "__pw_stack__", None
+        ) or inspect.stack(0)
+        parsed_st = _extract_stack_trace_information_from_stack(st, is_internal, title)
+        self._api_zone.set(parsed_st)
+        try:
+            return cb()
+        except Exception as error:
+            raise rewrite_error(error, f"{parsed_st['apiName']}: {error}") from None
+        finally:
+            self._api_zone.set(None)
+
 
 def from_channel(channel: Channel) -> Any:
     return channel._object
@@ -277,3 +585,89 @@ def from_channel(channel: Channel) -> Any:
 
 def from_nullable_channel(channel: Optional[Channel]) -> Optional[Any]:
     return channel._object if channel else None
+
+
+class StackFrame(TypedDict):
+    file: str
+    line: int
+    column: int
+    function: Optional[str]
+
+
+class ParsedStackTrace(TypedDict):
+    frames: List[StackFrame]
+    apiName: Optional[str]
+    title: Optional[str]
+
+
+def _extract_stack_trace_information_from_stack(
+    st: List[inspect.FrameInfo], is_internal: bool, title: str = None
+) -> ParsedStackTrace:
+    playwright_module_path = str(Path(playwright.__file__).parents[0])
+    last_internal_api_name = ""
+    api_name = ""
+    parsed_frames: List[StackFrame] = []
+    for frame in st:
+        # Sync and Async implementations can have event handlers. When these are sync, they
+        # get evaluated in the context of the event loop, so they contain the stack trace of when
+        # the message was received. _impl_to_api_mapping is glue between the user-code and internal
+        # code to translate impl classes to api classes. We want to ignore these frames.
+        if playwright._impl._impl_to_api_mapping.__file__ == frame.filename:
+            continue
+        is_playwright_internal = frame.filename.startswith(playwright_module_path)
+
+        method_name = ""
+        if "self" in frame[0].f_locals:
+            method_name = frame[0].f_locals["self"].__class__.__name__ + "."
+        method_name += frame[0].f_code.co_name
+
+        if not is_playwright_internal:
+            parsed_frames.append(
+                {
+                    "file": frame.filename,
+                    "line": frame.lineno,
+                    "column": 0,
+                    "function": method_name,
+                }
+            )
+        if is_playwright_internal:
+            last_internal_api_name = method_name
+        elif last_internal_api_name:
+            api_name = last_internal_api_name
+            last_internal_api_name = ""
+    if not api_name:
+        api_name = last_internal_api_name
+
+    return {
+        "frames": parsed_frames,
+        "apiName": "" if is_internal else api_name,
+        "title": title,
+    }
+
+
+def _augment_params(
+    params: Optional[Dict],
+    timeout_calculator: Optional[Callable[[Optional[float]], float]],
+) -> Dict:
+    if params is None:
+        params = {}
+    if timeout_calculator:
+        params["timeout"] = timeout_calculator(params.get("timeout"))
+    return _filter_none(params)
+
+
+def _filter_none(d: Mapping) -> Dict:
+    result = {}
+    for k, v in d.items():
+        if v is None:
+            continue
+        result[k] = _filter_none(v) if isinstance(v, dict) else v
+    return result
+
+
+def format_call_log(log: Optional[List[str]]) -> str:
+    if not log:
+        return ""
+    if len(list(filter(lambda x: x.strip(), log))) == 0:
+        return ""
+    return "\nCall log:\n" + "\n".join(log) + "\n"
diff --git a/playwright/_impl/_console_message.py b/playwright/_impl/_console_message.py
index 00bb6eaf9..66879194e 100644
--- a/playwright/_impl/_console_message.py
+++ b/playwright/_impl/_console_message.py
@@ -12,35 +12,87 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, List
+from asyncio import AbstractEventLoop
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union
 
-from playwright._impl._api_types import SourceLocation
-from playwright._impl._connection import ChannelOwner, from_channel
+from playwright._impl._api_structures import SourceLocation
+from playwright._impl._connection import from_channel, from_nullable_channel
 from playwright._impl._js_handle import JSHandle
 
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._page import Page
+    from playwright._impl._worker import Worker
 
-class ConsoleMessage(ChannelOwner):
+
+class ConsoleMessage:
     def __init__(
-        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+        self, event: Dict, loop: AbstractEventLoop, dispatcher_fiber: Any
     ) -> None:
-        super().__init__(parent, type, guid, initializer)
+        self._event = event
+        self._loop = loop
+        self._dispatcher_fiber = dispatcher_fiber
+        self._page: Optional["Page"] = from_nullable_channel(event.get("page"))
+        self._worker: Optional["Worker"] = from_nullable_channel(event.get("worker"))
+
+    def __repr__(self) -> str:
+        return f"<ConsoleMessage type={self.type} text={self.text}>"
 
     def __str__(self) -> str:
         return self.text
 
     @property
-    def type(self) -> str:
-        return self._initializer["type"]
+    def type(self) -> Union[
+        Literal["assert"],
+        Literal["clear"],
+        Literal["count"],
+        Literal["debug"],
+        Literal["dir"],
+        Literal["dirxml"],
+        Literal["endGroup"],
+        Literal["error"],
+        Literal["info"],
+        Literal["log"],
+        Literal["profile"],
+        Literal["profileEnd"],
+        Literal["startGroup"],
+        Literal["startGroupCollapsed"],
+        Literal["table"],
+        Literal["time"],
+        Literal["timeEnd"],
+        Literal["trace"],
+        Literal["warning"],
+    ]:
+        return self._event["type"]
 
     @property
     def text(self) -> str:
-        return self._initializer["text"]
+        return self._event["text"]
 
     @property
     def args(self) -> List[JSHandle]:
-        return list(map(from_channel, self._initializer["args"]))
+        return list(map(from_channel, self._event["args"]))
 
     @property
     def location(self) -> SourceLocation:
-        loc = self._initializer["location"]
-        return SourceLocation(loc["url"], loc["lineNumber"], loc["columnNumber"])
+        # Wire format uses `lineNumber`/`columnNumber`; docs expose both `line`/`column`
+        # (legacy) and `lineNumber`/`columnNumber` (added upstream in 1.60).
+        loc = self._event["location"]
+        return {
+            "url": loc["url"],
+            "line": loc["lineNumber"],
+            "column": loc["columnNumber"],
+            "lineNumber": loc["lineNumber"],
+            "columnNumber": loc["columnNumber"],
+        }
+
+    @property
+    def timestamp(self) -> float:
+        return self._event["timestamp"]
+
+    @property
+    def page(self) -> Optional["Page"]:
+        return self._page
+
+    @property
+    def worker(self) -> Optional["Worker"]:
+        return self._worker
diff --git a/playwright/_impl/_debugger.py b/playwright/_impl/_debugger.py
new file mode 100644
index 000000000..36e4bd989
--- /dev/null
+++ b/playwright/_impl/_debugger.py
@@ -0,0 +1,54 @@
+# 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.
+
+from types import SimpleNamespace
+from typing import Any, Dict, Optional
+
+from playwright._impl._api_structures import DebuggerLocation, DebuggerPausedDetails
+from playwright._impl._connection import ChannelOwner
+
+
+class Debugger(ChannelOwner):
+    Events = SimpleNamespace(
+        PausedStateChanged="pausedstatechanged",
+    )
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._paused_details: Optional[DebuggerPausedDetails] = None
+        self._channel.on(
+            "pausedStateChanged", lambda params: self._on_paused_state_changed(params)
+        )
+
+    def _on_paused_state_changed(self, params: Dict[str, Any]) -> None:
+        self._paused_details = params.get("pausedDetails")
+        self.emit(Debugger.Events.PausedStateChanged)
+
+    async def request_pause(self) -> None:
+        await self._channel.send("requestPause", None)
+
+    async def resume(self) -> None:
+        await self._channel.send("resume", None)
+
+    async def next(self) -> None:
+        await self._channel.send("next", None)
+
+    async def run_to(self, location: DebuggerLocation) -> None:
+        await self._channel.send("runTo", None, {"location": location})
+
+    @property
+    def paused_details(self) -> Optional[DebuggerPausedDetails]:
+        return self._paused_details
diff --git a/playwright/_impl/_dialog.py b/playwright/_impl/_dialog.py
index a4aac4ea4..f6750e396 100644
--- a/playwright/_impl/_dialog.py
+++ b/playwright/_impl/_dialog.py
@@ -12,17 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict
+from typing import TYPE_CHECKING, Dict, Optional
 
-from playwright._impl._connection import ChannelOwner
+from playwright._impl._connection import ChannelOwner, from_nullable_channel
+from playwright._impl._errors import is_target_closed_error
 from playwright._impl._helper import locals_to_params
 
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._page import Page
+
 
 class Dialog(ChannelOwner):
     def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        self._page: Optional["Page"] = from_nullable_channel(initializer.get("page"))
+
+    def __repr__(self) -> str:
+        return f"<Dialog type={self.type} message={self.message} default_value={self.default_value}>"
 
     @property
     def type(self) -> str:
@@ -33,11 +41,23 @@ def message(self) -> str:
         return self._initializer["message"]
 
     @property
-    def defaultValue(self) -> str:
+    def default_value(self) -> str:
         return self._initializer["defaultValue"]
 
+    @property
+    def page(self) -> Optional["Page"]:
+        return self._page
+
     async def accept(self, promptText: str = None) -> None:
-        await self._channel.send("accept", locals_to_params(locals()))
+        await self._channel.send("accept", None, locals_to_params(locals()))
 
     async def dismiss(self) -> None:
-        await self._channel.send("dismiss")
+        try:
+            await self._channel.send(
+                "dismiss",
+                None,
+            )
+        except Exception as e:
+            if is_target_closed_error(e):
+                return
+            raise
diff --git a/playwright/_impl/_disposable.py b/playwright/_impl/_disposable.py
new file mode 100644
index 000000000..c0b7e85a1
--- /dev/null
+++ b/playwright/_impl/_disposable.py
@@ -0,0 +1,93 @@
+# 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 asyncio
+import inspect
+import traceback
+from typing import Awaitable, Callable, Dict
+
+import greenlet
+
+from playwright._impl._connection import ChannelOwner
+from playwright._impl._errors import Error, is_target_closed_error
+
+
+class Disposable(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+
+    async def dispose(self) -> None:
+        try:
+            await self._channel.send(
+                "dispose",
+                None,
+            )
+        except Exception as e:
+            if not is_target_closed_error(e):
+                raise e
+
+    async def close(self) -> None:
+        await self.dispose()
+
+    def __repr__(self) -> str:
+        return "<Disposable>"
+
+
+class DisposableStub:
+    def __init__(
+        self,
+        dispose_fn: Callable[[], Awaitable[None]],
+        parent: ChannelOwner,
+    ) -> None:
+        self._dispose_fn = dispose_fn
+        self._loop = parent._loop
+        self._dispatcher_fiber = parent._dispatcher_fiber
+
+    async def dispose(self) -> None:
+        await self._dispose_fn()
+
+    async def __aenter__(self) -> "DisposableStub":
+        return self
+
+    async def __aexit__(self, *args: object) -> None:
+        await self.dispose()
+
+    def __enter__(self) -> "DisposableStub":
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self._sync(self.dispose())
+
+    def _sync(self, coro: object) -> object:
+        __tracebackhide__ = True
+        if self._loop.is_closed():
+            coro.close()  # type: ignore
+            raise Error("Event loop is closed! Is Playwright already stopped?")
+        g_self = greenlet.getcurrent()
+        task = self._loop.create_task(coro)  # type: ignore
+        setattr(task, "__pw_stack__", inspect.stack(0))
+        setattr(task, "__pw_stack_trace__", traceback.extract_stack(limit=10))
+        task.add_done_callback(lambda _: g_self.switch())
+        while not task.done():
+            self._dispatcher_fiber.switch()  # type: ignore
+        asyncio._set_running_loop(self._loop)
+        return task.result()
+
+    async def close(self) -> None:
+        await self.dispose()
+
+    def __repr__(self) -> str:
+        return "<Disposable>"
diff --git a/playwright/_impl/_download.py b/playwright/_impl/_download.py
index aaed90780..ffaf5cacd 100644
--- a/playwright/_impl/_download.py
+++ b/playwright/_impl/_download.py
@@ -12,36 +12,53 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import pathlib
 from pathlib import Path
-from typing import Dict, Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 
-from playwright._impl._connection import ChannelOwner
-from playwright._impl._helper import patch_error_message
+from playwright._impl._artifact import Artifact
 
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._page import Page
 
-class Download(ChannelOwner):
+
+class Download:
     def __init__(
-        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+        self, page: "Page", url: str, suggested_filename: str, artifact: Artifact
     ) -> None:
-        super().__init__(parent, type, guid, initializer)
+        self._page = page
+        self._loop = page._loop
+        self._dispatcher_fiber = page._dispatcher_fiber
+        self._url = url
+        self._suggested_filename = suggested_filename
+        self._artifact = artifact
+
+    def __repr__(self) -> str:
+        return f"<Download url={self.url!r} suggested_filename={self.suggested_filename!r}>"
+
+    @property
+    def page(self) -> "Page":
+        return self._page
 
     @property
     def url(self) -> str:
-        return self._initializer["url"]
+        return self._url
 
     @property
-    def suggestedFilename(self) -> str:
-        return self._initializer["suggestedFilename"]
+    def suggested_filename(self) -> str:
+        return self._suggested_filename
 
     async def delete(self) -> None:
-        await self._channel.send("delete")
+        await self._artifact.delete()
 
     async def failure(self) -> Optional[str]:
-        return patch_error_message(await self._channel.send("failure"))
+        return await self._artifact.failure()
+
+    async def path(self) -> pathlib.Path:
+        return await self._artifact.path_after_finished()
 
-    async def path(self) -> Optional[str]:
-        return await self._channel.send("path")
+    async def save_as(self, path: Union[str, Path]) -> None:
+        await self._artifact.save_as(path)
 
-    async def saveAs(self, path: Union[str, Path]) -> None:
-        path = str(Path(path))
-        return await self._channel.send("saveAs", dict(path=path))
+    async def cancel(self) -> None:
+        return await self._artifact.cancel()
diff --git a/playwright/_impl/_driver.py b/playwright/_impl/_driver.py
index d11906e60..22b53b8e7 100644
--- a/playwright/_impl/_driver.py
+++ b/playwright/_impl/_driver.py
@@ -12,31 +12,30 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import asyncio
 import inspect
+import os
 import sys
 from pathlib import Path
+from typing import Tuple
 
 import playwright
-from playwright._impl._logger import init_logger
+from playwright._repo_version import version
 
 
-def compute_driver_executable() -> Path:
-    package_path = Path(inspect.getfile(playwright)).parent
-    platform = sys.platform
-    if platform == "win32":
-        return package_path / "driver" / "playwright-cli.exe"
-    return package_path / "driver" / "playwright-cli"
-
-
-if sys.version_info.major == 3 and sys.version_info.minor == 7:
+def compute_driver_executable() -> Tuple[str, str]:
+    driver_path = Path(inspect.getfile(playwright)).parent / "driver"
+    cli_path = str(driver_path / "package" / "cli.js")
     if sys.platform == "win32":
-        # Use ProactorEventLoop in 3.7, which is default in 3.8
-        asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
-    else:
-        # Prevent Python 3.7 from throwing on Linux:
-        # RuntimeError: Cannot add child handler, the child watcher does not have a loop attached
-        asyncio.get_event_loop()
-        asyncio.get_child_watcher()
+        return (
+            os.getenv("PLAYWRIGHT_NODEJS_PATH", str(driver_path / "node.exe")),
+            cli_path,
+        )
+    return (os.getenv("PLAYWRIGHT_NODEJS_PATH", str(driver_path / "node")), cli_path)
+
 
-init_logger()
+def get_driver_env() -> dict:
+    env = os.environ.copy()
+    env["PW_LANG_NAME"] = "python"
+    env["PW_LANG_NAME_VERSION"] = f"{sys.version_info.major}.{sys.version_info.minor}"
+    env["PW_CLI_DISPLAY_VERSION"] = version
+    return env
diff --git a/playwright/_impl/_element_handle.py b/playwright/_impl/_element_handle.py
index ea12d42c4..3854669d0 100644
--- a/playwright/_impl/_element_handle.py
+++ b/playwright/_impl/_element_handle.py
@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import base64
-import sys
+import mimetypes
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
@@ -21,30 +21,34 @@
     Callable,
     Dict,
     List,
+    Literal,
     Optional,
-    Tuple,
+    Sequence,
     Union,
     cast,
 )
 
-from playwright._impl._api_types import FilePayload, FloatRect, filter_out_none
+from playwright._impl._api_structures import FilePayload, FloatRect, Position
 from playwright._impl._connection import ChannelOwner, from_nullable_channel
-from playwright._impl._file_chooser import normalize_file_payloads
-from playwright._impl._helper import KeyboardModifier, MouseButton, locals_to_params
+from playwright._impl._helper import (
+    Error,
+    KeyboardModifier,
+    MouseButton,
+    async_writefile,
+    locals_to_params,
+    make_dirs_for_file,
+)
 from playwright._impl._js_handle import (
     JSHandle,
     Serializable,
     parse_result,
     serialize_argument,
 )
-
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import Literal
-else:  # pragma: no cover
-    from typing_extensions import Literal
+from playwright._impl._set_input_files_helpers import convert_input_files
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._frame import Frame
+    from playwright._impl._locator import Locator
 
 
 class ElementHandle(JSHandle):
@@ -52,266 +56,411 @@ def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        self._frame = cast("Frame", parent)
 
     async def _createSelectorForTest(self, name: str) -> Optional[str]:
-        return await self._channel.send("createSelectorForTest", dict(name=name))
-
-    def toString(self) -> str:
-        return self._preview
+        return await self._channel.send(
+            "createSelectorForTest", self._frame._timeout, dict(name=name)
+        )
 
-    def asElement(self) -> Optional["ElementHandle"]:
+    def as_element(self) -> Optional["ElementHandle"]:
         return self
 
-    async def ownerFrame(self) -> Optional["Frame"]:
-        return from_nullable_channel(await self._channel.send("ownerFrame"))
+    async def owner_frame(self) -> Optional["Frame"]:
+        return from_nullable_channel(await self._channel.send("ownerFrame", None))
+
+    async def content_frame(self) -> Optional["Frame"]:
+        return from_nullable_channel(await self._channel.send("contentFrame", None))
+
+    async def get_attribute(self, name: str) -> Optional[str]:
+        return await self._channel.send("getAttribute", None, dict(name=name))
+
+    async def text_content(self) -> Optional[str]:
+        return await self._channel.send("textContent", None)
+
+    async def inner_text(self) -> str:
+        return await self._channel.send("innerText", None)
+
+    async def inner_html(self) -> str:
+        return await self._channel.send("innerHTML", None)
 
-    async def contentFrame(self) -> Optional["Frame"]:
-        return from_nullable_channel(await self._channel.send("contentFrame"))
+    async def is_checked(self) -> bool:
+        return await self._channel.send("isChecked", None)
 
-    async def getAttribute(self, name: str) -> Optional[str]:
-        return await self._channel.send("getAttribute", dict(name=name))
+    async def is_disabled(self) -> bool:
+        return await self._channel.send("isDisabled", None)
 
-    async def textContent(self) -> Optional[str]:
-        return await self._channel.send("textContent")
+    async def is_editable(self) -> bool:
+        return await self._channel.send("isEditable", None)
 
-    async def innerText(self) -> str:
-        return await self._channel.send("innerText")
+    async def is_enabled(self) -> bool:
+        return await self._channel.send("isEnabled", None)
 
-    async def innerHTML(self) -> str:
-        return await self._channel.send("innerHTML")
+    async def is_hidden(self) -> bool:
+        return await self._channel.send("isHidden", None)
 
-    async def dispatchEvent(self, type: str, eventInit: Dict = None) -> None:
+    async def is_visible(self) -> bool:
+        return await self._channel.send("isVisible", None)
+
+    async def dispatch_event(self, type: str, eventInit: Dict = None) -> None:
         await self._channel.send(
-            "dispatchEvent", dict(type=type, eventInit=serialize_argument(eventInit))
+            "dispatchEvent",
+            None,
+            dict(type=type, eventInit=serialize_argument(eventInit)),
         )
 
-    async def scrollIntoViewIfNeeded(self, timeout: int = None) -> None:
-        await self._channel.send("scrollIntoViewIfNeeded", locals_to_params(locals()))
+    async def scroll_into_view_if_needed(self, timeout: float = None) -> None:
+        await self._channel.send(
+            "scrollIntoViewIfNeeded", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def hover(
         self,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        timeout: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
         force: bool = None,
+        trial: bool = None,
     ) -> None:
-        await self._channel.send("hover", locals_to_params(locals()))
+        await self._channel.send(
+            "hover", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def click(
         self,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        delay: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
         button: MouseButton = None,
         clickCount: int = None,
-        timeout: int = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        trial: bool = None,
+        steps: int = None,
     ) -> None:
-        await self._channel.send("click", locals_to_params(locals()))
+        await self._channel.send(
+            "click", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def dblclick(
         self,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        delay: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
         button: MouseButton = None,
-        timeout: int = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        trial: bool = None,
+        steps: int = None,
     ) -> None:
-        await self._channel.send("dblclick", locals_to_params(locals()))
+        await self._channel.send(
+            "dblclick", self._frame._timeout, locals_to_params(locals())
+        )
 
-    async def selectOption(
+    async def select_option(
         self,
-        value: Union[str, List[str]] = None,
-        index: Union[int, List[int]] = None,
-        label: Union[str, List[str]] = None,
-        element: Union["ElementHandle", List["ElementHandle"]] = None,
-        timeout: int = None,
+        value: Union[str, Sequence[str]] = None,
+        index: Union[int, Sequence[int]] = None,
+        label: Union[str, Sequence[str]] = None,
+        element: Union["ElementHandle", Sequence["ElementHandle"]] = None,
+        timeout: float = None,
+        force: bool = None,
         noWaitAfter: bool = None,
     ) -> List[str]:
         params = locals_to_params(
             dict(
                 timeout=timeout,
-                noWaitAfter=noWaitAfter,
-                **convert_select_option_values(value, index, label, element)
+                force=force,
+                **convert_select_option_values(value, index, label, element),
             )
         )
-        return await self._channel.send("selectOption", params)
+        return await self._channel.send("selectOption", self._frame._timeout, params)
 
     async def tap(
         self,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        timeout: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        trial: bool = None,
     ) -> None:
-        await self._channel.send("tap", locals_to_params(locals()))
+        await self._channel.send(
+            "tap", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def fill(
-        self, value: str, timeout: int = None, noWaitAfter: bool = None
+        self,
+        value: str,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        force: bool = None,
     ) -> None:
-        await self._channel.send("fill", locals_to_params(locals()))
+        await self._channel.send(
+            "fill", self._frame._timeout, locals_to_params(locals())
+        )
+
+    async def select_text(self, force: bool = None, timeout: float = None) -> None:
+        await self._channel.send(
+            "selectText", self._frame._timeout, locals_to_params(locals())
+        )
 
-    async def selectText(self, timeout: int = None) -> None:
-        await self._channel.send("selectText", locals_to_params(locals()))
+    async def input_value(self, timeout: float = None) -> str:
+        return await self._channel.send(
+            "inputValue", self._frame._timeout, locals_to_params(locals())
+        )
 
-    async def setInputFiles(
+    async def set_input_files(
         self,
-        files: Union[str, Path, FilePayload, List[str], List[Path], List[FilePayload]],
-        timeout: int = None,
+        files: Union[
+            str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
+        ],
+        timeout: float = None,
         noWaitAfter: bool = None,
     ) -> None:
-        params = locals_to_params(locals())
-        params["files"] = normalize_file_payloads(files)
-        await self._channel.send("setInputFiles", params)
+        frame = await self.owner_frame()
+        if not frame:
+            raise Error("Cannot set input files to detached element")
+        converted = await convert_input_files(files, frame.page.context)
+        await self._channel.send(
+            "setInputFiles",
+            self._frame._timeout,
+            {
+                "timeout": timeout,
+                **converted,
+            },
+        )
 
     async def focus(self) -> None:
-        await self._channel.send("focus")
+        await self._channel.send("focus", None)
 
     async def type(
         self,
         text: str,
-        delay: int = None,
-        timeout: int = None,
+        delay: float = None,
+        timeout: float = None,
         noWaitAfter: bool = None,
     ) -> None:
-        await self._channel.send("type", locals_to_params(locals()))
+        await self._channel.send(
+            "type", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def press(
-        self, key: str, delay: int = None, timeout: int = None, noWaitAfter: bool = None
+        self,
+        key: str,
+        delay: float = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
     ) -> None:
-        await self._channel.send("press", locals_to_params(locals()))
+        await self._channel.send(
+            "press", self._frame._timeout, locals_to_params(locals())
+        )
+
+    async def set_checked(
+        self,
+        checked: bool,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        trial: bool = None,
+    ) -> None:
+        if checked:
+            await self.check(
+                position=position,
+                timeout=timeout,
+                force=force,
+                trial=trial,
+            )
+        else:
+            await self.uncheck(
+                position=position,
+                timeout=timeout,
+                force=force,
+                trial=trial,
+            )
 
     async def check(
-        self, timeout: int = None, force: bool = None, noWaitAfter: bool = None
+        self,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        trial: bool = None,
     ) -> None:
-        await self._channel.send("check", locals_to_params(locals()))
+        await self._channel.send(
+            "check", self._frame._timeout, locals_to_params(locals())
+        )
 
     async def uncheck(
-        self, timeout: int = None, force: bool = None, noWaitAfter: bool = None
+        self,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        trial: bool = None,
     ) -> None:
-        await self._channel.send("uncheck", locals_to_params(locals()))
+        await self._channel.send(
+            "uncheck", self._frame._timeout, locals_to_params(locals())
+        )
 
-    async def boundingBox(self) -> Optional[FloatRect]:
-        bb = await self._channel.send("boundingBox")
-        return FloatRect._parse(bb)
+    async def bounding_box(self) -> Optional[FloatRect]:
+        return await self._channel.send("boundingBox", None)
 
     async def screenshot(
         self,
-        timeout: int = None,
+        timeout: float = None,
         type: Literal["jpeg", "png"] = None,
         path: Union[str, Path] = None,
         quality: int = None,
         omitBackground: bool = None,
+        animations: Literal["allow", "disabled"] = None,
+        caret: Literal["hide", "initial"] = None,
+        scale: Literal["css", "device"] = None,
+        mask: Sequence["Locator"] = None,
+        maskColor: str = None,
+        style: str = None,
     ) -> bytes:
         params = locals_to_params(locals())
         if "path" in params:
+            if "type" not in params:
+                params["type"] = determine_screenshot_type(params["path"])
             del params["path"]
-        encoded_binary = await self._channel.send("screenshot", params)
+        if "mask" in params:
+            params["mask"] = list(
+                map(
+                    lambda locator: (
+                        {
+                            "frame": locator._frame._channel,
+                            "selector": locator._selector,
+                        }
+                    ),
+                    params["mask"],
+                )
+            )
+        encoded_binary = await self._channel.send(
+            "screenshot", self._frame._timeout, params
+        )
         decoded_binary = base64.b64decode(encoded_binary)
         if path:
-            with open(path, "wb") as fd:
-                fd.write(decoded_binary)
+            make_dirs_for_file(path)
+            await async_writefile(path, decoded_binary)
         return decoded_binary
 
-    async def querySelector(self, selector: str) -> Optional["ElementHandle"]:
+    async def query_selector(self, selector: str) -> Optional["ElementHandle"]:
         return from_nullable_channel(
-            await self._channel.send("querySelector", dict(selector=selector))
+            await self._channel.send("querySelector", None, dict(selector=selector))
         )
 
-    async def querySelectorAll(self, selector: str) -> List["ElementHandle"]:
+    async def query_selector_all(self, selector: str) -> List["ElementHandle"]:
         return list(
             map(
                 cast(Callable[[Any], Any], from_nullable_channel),
-                await self._channel.send("querySelectorAll", dict(selector=selector)),
+                await self._channel.send(
+                    "querySelectorAll", None, dict(selector=selector)
+                ),
             )
         )
 
-    async def evalOnSelector(
+    async def eval_on_selector(
         self,
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
     ) -> Any:
         return parse_result(
             await self._channel.send(
                 "evalOnSelector",
+                None,
                 dict(
                     selector=selector,
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
-    async def evalOnSelectorAll(
+    async def eval_on_selector_all(
         self,
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
     ) -> Any:
         return parse_result(
             await self._channel.send(
                 "evalOnSelectorAll",
+                None,
                 dict(
                     selector=selector,
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
-    async def waitForElementState(
+    async def wait_for_element_state(
         self,
-        state: Literal["disabled", "enabled", "hidden", "stable", "visible"],
-        timeout: int = None,
+        state: Literal[
+            "disabled", "editable", "enabled", "hidden", "stable", "visible"
+        ],
+        timeout: float = None,
     ) -> None:
-        await self._channel.send("waitForElementState", locals_to_params(locals()))
+        await self._channel.send(
+            "waitForElementState", self._frame._timeout, locals_to_params(locals())
+        )
 
-    async def waitForSelector(
+    async def wait_for_selector(
         self,
         selector: str,
         state: Literal["attached", "detached", "hidden", "visible"] = None,
-        timeout: int = None,
+        timeout: float = None,
+        strict: bool = None,
     ) -> Optional["ElementHandle"]:
         return from_nullable_channel(
-            await self._channel.send("waitForSelector", locals_to_params(locals()))
+            await self._channel.send(
+                "waitForSelector", self._frame._timeout, locals_to_params(locals())
+            )
         )
 
 
 def convert_select_option_values(
-    value: Union[str, List[str]] = None,
-    index: Union[int, List[int]] = None,
-    label: Union[str, List[str]] = None,
-    element: Union["ElementHandle", List["ElementHandle"]] = None,
+    value: Union[str, Sequence[str]] = None,
+    index: Union[int, Sequence[int]] = None,
+    label: Union[str, Sequence[str]] = None,
+    element: Union["ElementHandle", Sequence["ElementHandle"]] = None,
 ) -> Any:
     if value is None and index is None and label is None and element is None:
         return {}
 
     options: Any = None
     elements: Any = None
-    if value:
-        if not isinstance(value, list):
+    if value is not None:
+        if isinstance(value, str):
             value = [value]
-        options = (options or []) + list(map(lambda e: dict(value=e), value))
-    if index:
-        if not isinstance(index, list):
+        options = (options or []) + list(map(lambda e: dict(valueOrLabel=e), value))
+    if index is not None:
+        if isinstance(index, int):
             index = [index]
         options = (options or []) + list(map(lambda e: dict(index=e), index))
-    if label:
-        if not isinstance(label, list):
+    if label is not None:
+        if isinstance(label, str):
             label = [label]
         options = (options or []) + list(map(lambda e: dict(label=e), label))
     if element:
-        if not isinstance(element, list):
+        if isinstance(element, ElementHandle):
             element = [element]
         elements = list(map(lambda e: e._channel, element))
 
-    return filter_out_none(dict(options=options, elements=elements))
+    return dict(options=options, elements=elements)
+
+
+def determine_screenshot_type(path: Union[str, Path]) -> Literal["jpeg", "png"]:
+    mime_type, _ = mimetypes.guess_type(path)
+    if mime_type == "image/png":
+        return "png"
+    if mime_type == "image/jpeg":
+        return "jpeg"
+    raise Error(f'Unsupported screenshot mime type for path "{path}": {mime_type}')
diff --git a/playwright/_impl/_errors.py b/playwright/_impl/_errors.py
new file mode 100644
index 000000000..c47d918ef
--- /dev/null
+++ b/playwright/_impl/_errors.py
@@ -0,0 +1,60 @@
+# 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.
+
+# These are types that we use in the API. They are public and are a part of the
+# stable API.
+
+
+from typing import Optional
+
+
+def is_target_closed_error(error: Exception) -> bool:
+    return isinstance(error, TargetClosedError)
+
+
+class Error(Exception):
+    def __init__(self, message: str) -> None:
+        self._message = message
+        self._name: Optional[str] = None
+        self._stack: Optional[str] = None
+        super().__init__(message)
+
+    @property
+    def message(self) -> str:
+        return self._message
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @property
+    def stack(self) -> Optional[str]:
+        return self._stack
+
+
+class TimeoutError(Error):
+    pass
+
+
+class TargetClosedError(Error):
+    def __init__(self, message: str = None) -> None:
+        super().__init__(message or "Target page, context or browser has been closed")
+
+
+def rewrite_error(error: Exception, message: str) -> Exception:
+    rewritten_exc = type(error)(message)
+    if isinstance(rewritten_exc, Error) and isinstance(error, Error):
+        rewritten_exc._name = error.name
+        rewritten_exc._stack = error.stack
+    return rewritten_exc
diff --git a/playwright/_impl/_event_context_manager.py b/playwright/_impl/_event_context_manager.py
index 23306f0d7..13191f0cf 100644
--- a/playwright/_impl/_event_context_manager.py
+++ b/playwright/_impl/_event_context_manager.py
@@ -13,31 +13,21 @@
 # limitations under the License.
 
 import asyncio
-from typing import Any, Coroutine, Generic, Optional, TypeVar, cast
+from typing import Any, Generic, TypeVar
 
 T = TypeVar("T")
 
 
-class EventInfoImpl(Generic[T]):
-    def __init__(self, coroutine: Coroutine) -> None:
-        self._value: Optional[T] = None
-        self._task = asyncio.get_event_loop().create_task(coroutine)
-        self._done = False
+class EventContextManagerImpl(Generic[T]):
+    def __init__(self, future: asyncio.Future) -> None:
+        self._future: asyncio.Future = future
 
     @property
-    async def value(self) -> T:
-        if not self._done:
-            self._value = await self._task
-            self._done = True
-        return cast(T, self._value)
-
-
-class EventContextManagerImpl(Generic[T]):
-    def __init__(self, coroutine: Coroutine) -> None:
-        self._event: EventInfoImpl = EventInfoImpl(coroutine)
+    def future(self) -> asyncio.Future:
+        return self._future
 
-    async def __aenter__(self) -> EventInfoImpl[T]:
-        return self._event
+    async def __aenter__(self) -> asyncio.Future:
+        return self._future
 
     async def __aexit__(self, *args: Any) -> None:
-        await self._event.value
+        await self._future
diff --git a/playwright/_impl/_fetch.py b/playwright/_impl/_fetch.py
new file mode 100644
index 000000000..a14378149
--- /dev/null
+++ b/playwright/_impl/_fetch.py
@@ -0,0 +1,599 @@
+# 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 base64
+import json
+import mimetypes
+import pathlib
+import typing
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union, cast
+
+import playwright._impl._network as network
+from playwright._impl._api_structures import (
+    ClientCertificate,
+    FilePayload,
+    FormField,
+    Headers,
+    HttpCredentials,
+    ProxySettings,
+    ServerFilePayload,
+    StorageState,
+)
+from playwright._impl._connection import ChannelOwner, from_channel
+from playwright._impl._errors import is_target_closed_error
+from playwright._impl._form_data import FormData
+from playwright._impl._helper import (
+    Error,
+    NameValue,
+    TargetClosedError,
+    TimeoutSettings,
+    async_readfile,
+    async_writefile,
+    is_file_payload,
+    locals_to_params,
+    object_to_array,
+    to_impl,
+)
+from playwright._impl._network import serialize_headers, to_client_certificates_protocol
+from playwright._impl._tracing import Tracing
+
+if typing.TYPE_CHECKING:
+    from playwright._impl._playwright import Playwright
+
+
+FormType = Union[Dict[str, Union[bool, float, str]], FormData]
+DataType = Union[Any, bytes, str]
+MultipartType = Union[Dict[str, Union[bytes, bool, float, str, FilePayload]], FormData]
+ParamsType = Union[Dict[str, Union[bool, float, str]], str]
+
+
+class APIRequest:
+    def __init__(self, playwright: "Playwright") -> None:
+        self.playwright = playwright
+        self._loop = playwright._loop
+        self._dispatcher_fiber = playwright._connection._dispatcher_fiber
+
+    async def new_context(
+        self,
+        baseURL: str = None,
+        extraHTTPHeaders: Dict[str, str] = None,
+        httpCredentials: HttpCredentials = None,
+        ignoreHTTPSErrors: bool = None,
+        proxy: ProxySettings = None,
+        userAgent: str = None,
+        timeout: float = None,
+        storageState: Union[StorageState, str, Path] = None,
+        clientCertificates: List[ClientCertificate] = None,
+        failOnStatusCode: bool = None,
+        maxRedirects: int = None,
+    ) -> "APIRequestContext":
+        params = locals_to_params(locals())
+        if "storageState" in params:
+            storage_state = params["storageState"]
+            if not isinstance(storage_state, dict) and storage_state:
+                params["storageState"] = json.loads(
+                    (await async_readfile(storage_state)).decode()
+                )
+        if "extraHTTPHeaders" in params:
+            params["extraHTTPHeaders"] = serialize_headers(params["extraHTTPHeaders"])
+        params["clientCertificates"] = await to_client_certificates_protocol(
+            params.get("clientCertificates")
+        )
+        context = cast(
+            APIRequestContext,
+            from_channel(
+                await self.playwright._channel.send("newRequest", None, params)
+            ),
+        )
+        context._timeout_settings.set_default_timeout(timeout)
+        return context
+
+
+class APIRequestContext(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._tracing: Tracing = from_channel(initializer["tracing"])
+        self._close_reason: Optional[str] = None
+        self._timeout_settings = TimeoutSettings(None)
+
+    async def dispose(self, reason: str = None) -> None:
+        self._close_reason = reason
+        await self._tracing._export_all_hars()
+        try:
+            await self._channel.send("dispose", None, {"reason": reason})
+        except Error as e:
+            if is_target_closed_error(e):
+                return
+            raise e
+        self._tracing._reset_stack_counter()
+
+    @property
+    def tracing(self) -> Tracing:
+        return self._tracing
+
+    async def delete(
+        self,
+        url: str,
+        params: ParamsType = None,
+        headers: Headers = None,
+        data: DataType = None,
+        form: FormType = None,
+        multipart: MultipartType = None,
+        timeout: float = None,
+        failOnStatusCode: bool = None,
+        ignoreHTTPSErrors: bool = None,
+        maxRedirects: int = None,
+        maxRetries: int = None,
+    ) -> "APIResponse":
+        return await self.fetch(
+            url,
+            method="DELETE",
+            params=params,
+            headers=headers,
+            data=data,
+            form=form,
+            multipart=multipart,
+            timeout=timeout,
+            failOnStatusCode=failOnStatusCode,
+            ignoreHTTPSErrors=ignoreHTTPSErrors,
+            maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
+        )
+
+    async def head(
+        self,
+        url: str,
+        params: ParamsType = None,
+        headers: Headers = None,
+        data: DataType = None,
+        form: FormType = None,
+        multipart: MultipartType = None,
+        timeout: float = None,
+        failOnStatusCode: bool = None,
+        ignoreHTTPSErrors: bool = None,
+        maxRedirects: int = None,
+        maxRetries: int = None,
+    ) -> "APIResponse":
+        return await self.fetch(
+            url,
+            method="HEAD",
+            params=params,
+            headers=headers,
+            data=data,
+            form=form,
+            multipart=multipart,
+            timeout=timeout,
+            failOnStatusCode=failOnStatusCode,
+            ignoreHTTPSErrors=ignoreHTTPSErrors,
+            maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
+        )
+
+    async def get(
+        self,
+        url: str,
+        params: ParamsType = None,
+        headers: Headers = None,
+        data: DataType = None,
+        form: FormType = None,
+        multipart: MultipartType = None,
+        timeout: float = None,
+        failOnStatusCode: bool = None,
+        ignoreHTTPSErrors: bool = None,
+        maxRedirects: int = None,
+        maxRetries: int = None,
+    ) -> "APIResponse":
+        return await self.fetch(
+            url,
+            method="GET",
+            params=params,
+            headers=headers,
+            data=data,
+            form=form,
+            multipart=multipart,
+            timeout=timeout,
+            failOnStatusCode=failOnStatusCode,
+            ignoreHTTPSErrors=ignoreHTTPSErrors,
+            maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
+        )
+
+    async def patch(
+        self,
+        url: str,
+        params: ParamsType = None,
+        headers: Headers = None,
+        data: DataType = None,
+        form: FormType = None,
+        multipart: MultipartType = None,
+        timeout: float = None,
+        failOnStatusCode: bool = None,
+        ignoreHTTPSErrors: bool = None,
+        maxRedirects: int = None,
+        maxRetries: int = None,
+    ) -> "APIResponse":
+        return await self.fetch(
+            url,
+            method="PATCH",
+            params=params,
+            headers=headers,
+            data=data,
+            form=form,
+            multipart=multipart,
+            timeout=timeout,
+            failOnStatusCode=failOnStatusCode,
+            ignoreHTTPSErrors=ignoreHTTPSErrors,
+            maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
+        )
+
+    async def put(
+        self,
+        url: str,
+        params: ParamsType = None,
+        headers: Headers = None,
+        data: DataType = None,
+        form: FormType = None,
+        multipart: MultipartType = None,
+        timeout: float = None,
+        failOnStatusCode: bool = None,
+        ignoreHTTPSErrors: bool = None,
+        maxRedirects: int = None,
+        maxRetries: int = None,
+    ) -> "APIResponse":
+        return await self.fetch(
+            url,
+            method="PUT",
+            params=params,
+            headers=headers,
+            data=data,
+            form=form,
+            multipart=multipart,
+            timeout=timeout,
+            failOnStatusCode=failOnStatusCode,
+            ignoreHTTPSErrors=ignoreHTTPSErrors,
+            maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
+        )
+
+    async def post(
+        self,
+        url: str,
+        params: ParamsType = None,
+        headers: Headers = None,
+        data: DataType = None,
+        form: FormType = None,
+        multipart: MultipartType = None,
+        timeout: float = None,
+        failOnStatusCode: bool = None,
+        ignoreHTTPSErrors: bool = None,
+        maxRedirects: int = None,
+        maxRetries: int = None,
+    ) -> "APIResponse":
+        return await self.fetch(
+            url,
+            method="POST",
+            params=params,
+            headers=headers,
+            data=data,
+            form=form,
+            multipart=multipart,
+            timeout=timeout,
+            failOnStatusCode=failOnStatusCode,
+            ignoreHTTPSErrors=ignoreHTTPSErrors,
+            maxRedirects=maxRedirects,
+            maxRetries=maxRetries,
+        )
+
+    async def fetch(
+        self,
+        urlOrRequest: Union[str, network.Request],
+        params: ParamsType = None,
+        method: str = None,
+        headers: Headers = None,
+        data: DataType = None,
+        form: FormType = None,
+        multipart: MultipartType = None,
+        timeout: float = None,
+        failOnStatusCode: bool = None,
+        ignoreHTTPSErrors: bool = None,
+        maxRedirects: int = None,
+        maxRetries: int = None,
+    ) -> "APIResponse":
+        url = urlOrRequest if isinstance(urlOrRequest, str) else None
+        request = (
+            cast(network.Request, to_impl(urlOrRequest))
+            if isinstance(to_impl(urlOrRequest), network.Request)
+            else None
+        )
+        assert request or isinstance(
+            urlOrRequest, str
+        ), "First argument must be either URL string or Request"
+        return await self._inner_fetch(
+            request,
+            url,
+            method,
+            headers,
+            data,
+            params,
+            form,
+            multipart,
+            timeout,
+            failOnStatusCode,
+            ignoreHTTPSErrors,
+            maxRedirects,
+            maxRetries,
+        )
+
+    async def _inner_fetch(
+        self,
+        request: Optional[network.Request],
+        url: Optional[str],
+        method: str = None,
+        headers: Headers = None,
+        data: DataType = None,
+        params: ParamsType = None,
+        form: FormType = None,
+        multipart: MultipartType = None,
+        timeout: float = None,
+        failOnStatusCode: bool = None,
+        ignoreHTTPSErrors: bool = None,
+        maxRedirects: int = None,
+        maxRetries: int = None,
+    ) -> "APIResponse":
+        if self._close_reason:
+            raise TargetClosedError(self._close_reason)
+        assert (
+            (1 if data else 0) + (1 if form else 0) + (1 if multipart else 0)
+        ) <= 1, "Only one of 'data', 'form' or 'multipart' can be specified"
+        assert (
+            maxRedirects is None or maxRedirects >= 0
+        ), "'max_redirects' must be greater than or equal to '0'"
+        assert (
+            maxRetries is None or maxRetries >= 0
+        ), "'max_retries' must be greater than or equal to '0'"
+        url = url or (request.url if request else url)
+        method = method or (request.method if request else "GET")
+        # Cannot call allHeaders() here as the request may be paused inside route handler.
+        headers_obj = headers or (request.headers if request else None)
+        serialized_headers = serialize_headers(headers_obj) if headers_obj else None
+        json_data: Any = None
+        form_data: Optional[List[NameValue]] = None
+        multipart_data: Optional[List[FormField]] = None
+        post_data_buffer: Optional[bytes] = None
+        if data is not None:
+            if isinstance(data, str):
+                if is_json_content_type(serialized_headers):
+                    json_data = data if is_json_parsable(data) else json.dumps(data)
+                else:
+                    post_data_buffer = data.encode()
+            elif isinstance(data, bytes):
+                post_data_buffer = data
+            elif isinstance(data, (dict, list, int, bool)):
+                json_data = json.dumps(data)
+            else:
+                raise Error(f"Unsupported 'data' type: {type(data)}")
+        elif form:
+            if isinstance(form, FormData):
+                form_data = []
+                for fd_name, fd_value in form._fields:
+                    if isinstance(fd_value, (pathlib.Path, dict)):
+                        raise Error(
+                            f"Form field {fd_name!r} must be a string, number or boolean. Use 'multipart' for file uploads."
+                        )
+                    form_data.append(NameValue(name=fd_name, value=str(fd_value)))
+            else:
+                form_data = object_to_array(form)
+        elif multipart:
+            multipart_data = []
+            if isinstance(multipart, FormData):
+                for fd_name, fd_value in multipart._fields:
+                    multipart_data.append(
+                        await _form_data_field_to_form_field(fd_name, fd_value)
+                    )
+            else:
+                # Convert file-like values to ServerFilePayload structs.
+                for name, value in multipart.items():
+                    if is_file_payload(value):
+                        payload = cast(FilePayload, value)
+                        assert isinstance(
+                            payload["buffer"], bytes
+                        ), f"Unexpected buffer type of 'data.{name}'"
+                        multipart_data.append(
+                            FormField(name=name, file=file_payload_to_json(payload))
+                        )
+                    elif isinstance(value, str):
+                        multipart_data.append(FormField(name=name, value=value))
+        if (
+            post_data_buffer is None
+            and json_data is None
+            and form_data is None
+            and multipart_data is None
+        ):
+            post_data_buffer = request.post_data_buffer if request else None
+        post_data = (
+            base64.b64encode(post_data_buffer).decode() if post_data_buffer else None
+        )
+
+        response = await self._channel.send(
+            "fetch",
+            self._timeout_settings.timeout,
+            {
+                "url": url,
+                "timeout": timeout,
+                "params": object_to_array(params) if isinstance(params, dict) else None,
+                "encodedParams": params if isinstance(params, str) else None,
+                "method": method,
+                "headers": serialized_headers,
+                "postData": post_data,
+                "jsonData": json_data,
+                "formData": form_data,
+                "multipartData": multipart_data,
+                "failOnStatusCode": failOnStatusCode,
+                "ignoreHTTPSErrors": ignoreHTTPSErrors,
+                "maxRedirects": maxRedirects,
+                "maxRetries": maxRetries,
+            },
+        )
+        return APIResponse(self, response)
+
+    async def storage_state(
+        self,
+        path: Union[pathlib.Path, str] = None,
+        indexedDB: bool = None,
+    ) -> StorageState:
+        result = await self._channel.send_return_as_dict(
+            "storageState", None, {"indexedDB": indexedDB}
+        )
+        if path:
+            await async_writefile(path, json.dumps(result))
+        return result
+
+
+def file_payload_to_json(payload: FilePayload) -> ServerFilePayload:
+    return ServerFilePayload(
+        name=payload["name"],
+        mimeType=payload["mimeType"],
+        buffer=base64.b64encode(payload["buffer"]).decode(),
+    )
+
+
+async def _form_data_field_to_form_field(name: str, value: Any) -> FormField:
+    if isinstance(value, pathlib.Path):
+        mime_type, _ = mimetypes.guess_type(str(value))
+        return FormField(
+            name=name,
+            file=ServerFilePayload(
+                name=value.name,
+                mimeType=mime_type or "application/octet-stream",
+                buffer=base64.b64encode(await async_readfile(str(value))).decode(),
+            ),
+        )
+    if is_file_payload(value):
+        payload = cast(FilePayload, value)
+        assert isinstance(
+            payload["buffer"], bytes
+        ), f"Unexpected buffer type of form field {name!r}"
+        return FormField(name=name, file=file_payload_to_json(payload))
+    if isinstance(value, (str, int, float, bool)):
+        return FormField(name=name, value=str(value))
+    raise Error(f"Unsupported form field {name!r} value type: {type(value).__name__}")
+
+
+class APIResponse:
+    def __init__(self, context: APIRequestContext, initializer: Dict) -> None:
+        self._loop = context._loop
+        self._dispatcher_fiber = context._connection._dispatcher_fiber
+        self._request = context
+        self._initializer = initializer
+        self._headers = network.RawHeaders(initializer["headers"])
+
+    def __repr__(self) -> str:
+        return f"<APIResponse url={self.url!r} status={self.status!r} status_text={self.status_text!r}>"
+
+    @property
+    def ok(self) -> bool:
+        return self.status >= 200 and self.status <= 299
+
+    @property
+    def url(self) -> str:
+        return self._initializer["url"]
+
+    @property
+    def status(self) -> int:
+        return self._initializer["status"]
+
+    @property
+    def status_text(self) -> str:
+        return self._initializer["statusText"]
+
+    @property
+    def headers(self) -> Headers:
+        return self._headers.headers()
+
+    @property
+    def headers_array(self) -> network.HeadersArray:
+        return self._headers.headers_array()
+
+    async def body(self) -> bytes:
+        try:
+            result = await self._request._connection.wrap_api_call(
+                lambda: self._request._channel.send_return_as_dict(
+                    "fetchResponseBody",
+                    None,
+                    {
+                        "fetchUid": self._fetch_uid,
+                    },
+                ),
+                True,
+            )
+            if result is None:
+                raise Error("Response has been disposed")
+            return base64.b64decode(result["binary"])
+        except Error as exc:
+            if is_target_closed_error(exc):
+                raise Error("Response has been disposed")
+            raise exc
+
+    async def text(self) -> str:
+        content = await self.body()
+        return content.decode()
+
+    async def json(self) -> Any:
+        content = await self.text()
+        return json.loads(content)
+
+    async def dispose(self) -> None:
+        await self._request._channel.send(
+            "disposeAPIResponse",
+            None,
+            {
+                "fetchUid": self._fetch_uid,
+            },
+        )
+
+    @property
+    def _fetch_uid(self) -> str:
+        return self._initializer["fetchUid"]
+
+    async def _fetch_log(self) -> List[str]:
+        return await self._request._channel.send(
+            "fetchLog",
+            None,
+            {
+                "fetchUid": self._fetch_uid,
+            },
+        )
+
+
+def is_json_content_type(headers: network.HeadersArray = None) -> bool:
+    if not headers:
+        return False
+    for header in headers:
+        if header["name"] == "Content-Type":
+            return header["value"].startswith("application/json")
+    return False
+
+
+def is_json_parsable(value: Any) -> bool:
+    if not isinstance(value, str):
+        return False
+    try:
+        json.loads(value)
+        return True
+    except json.JSONDecodeError:
+        return False
diff --git a/playwright/_impl/_file_chooser.py b/playwright/_impl/_file_chooser.py
index 064cba903..951919d22 100644
--- a/playwright/_impl/_file_chooser.py
+++ b/playwright/_impl/_file_chooser.py
@@ -12,13 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import base64
-import mimetypes
-import os
 from pathlib import Path
-from typing import TYPE_CHECKING, List, Union
+from typing import TYPE_CHECKING, Sequence, Union
 
-from playwright._impl._api_types import FilePayload
+from playwright._impl._api_structures import FilePayload
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._element_handle import ElementHandle
@@ -35,6 +32,9 @@ def __init__(
         self._element_handle = element_handle
         self._is_multiple = is_multiple
 
+    def __repr__(self) -> str:
+        return f"<FileChooser page={self._page} element={self._element_handle}>"
+
     @property
     def page(self) -> "Page":
         return self._page
@@ -43,42 +43,15 @@ def page(self) -> "Page":
     def element(self) -> "ElementHandle":
         return self._element_handle
 
-    @property
-    def isMultiple(self) -> bool:
+    def is_multiple(self) -> bool:
         return self._is_multiple
 
-    async def setFiles(
+    async def set_files(
         self,
-        files: Union[str, FilePayload, List[str], List[FilePayload]],
-        timeout: int = None,
+        files: Union[
+            str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
+        ],
+        timeout: float = None,
         noWaitAfter: bool = None,
     ) -> None:
-        await self._element_handle.setInputFiles(files, timeout, noWaitAfter)
-
-
-def normalize_file_payloads(
-    files: Union[str, Path, FilePayload, List[str], List[Path], List[FilePayload]]
-) -> List:
-    file_list = files if isinstance(files, list) else [files]
-    file_payloads: List = []
-    for item in file_list:
-        if isinstance(item, str) or isinstance(item, Path):
-            with open(item, mode="rb") as fd:
-                file_payloads.append(
-                    {
-                        "name": os.path.basename(item),
-                        "mimeType": mimetypes.guess_type(str(Path(item)))[0]
-                        or "application/octet-stream",
-                        "buffer": base64.b64encode(fd.read()).decode(),
-                    }
-                )
-        if isinstance(item, FilePayload):
-            file_payloads.append(
-                {
-                    "name": item.name,
-                    "mimeType": item.mime_type,
-                    "buffer": base64.b64encode(item.buffer).decode(),
-                }
-            )
-
-    return file_payloads
+        await self._element_handle.set_input_files(files, timeout, noWaitAfter)
diff --git a/playwright/_impl/_form_data.py b/playwright/_impl/_form_data.py
new file mode 100644
index 000000000..384806abd
--- /dev/null
+++ b/playwright/_impl/_form_data.py
@@ -0,0 +1,34 @@
+# 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 pathlib
+from typing import List, Tuple, Union
+
+from playwright._impl._api_structures import FilePayload
+
+FormDataValue = Union[bool, float, str, pathlib.Path, FilePayload]
+
+
+class FormData:
+    def __init__(self) -> None:
+        self._fields: List[Tuple[str, FormDataValue]] = []
+
+    def set(self, name: str, value: FormDataValue) -> "FormData":
+        self._fields = [(n, v) for (n, v) in self._fields if n != name]
+        self._fields.append((name, value))
+        return self
+
+    def append(self, name: str, value: FormDataValue) -> "FormData":
+        self._fields.append((name, value))
+        return self
diff --git a/playwright/_impl/_frame.py b/playwright/_impl/_frame.py
index 9b9e44625..2422f2b1a 100644
--- a/playwright/_impl/_frame.py
+++ b/playwright/_impl/_frame.py
@@ -13,45 +13,74 @@
 # limitations under the License.
 
 import asyncio
-import sys
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Tuple, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Pattern,
+    Sequence,
+    Set,
+    Union,
+    cast,
+)
 
 from pyee import EventEmitter
 
-from playwright._impl._api_types import Error, FilePayload
+from playwright._impl._api_structures import (
+    AriaRole,
+    DropPayload,
+    FilePayload,
+    FrameExpectOptions,
+    FrameExpectResult,
+    Position,
+)
 from playwright._impl._connection import (
     ChannelOwner,
     from_channel,
     from_nullable_channel,
 )
 from playwright._impl._element_handle import ElementHandle, convert_select_option_values
+from playwright._impl._errors import Error
 from playwright._impl._event_context_manager import EventContextManagerImpl
-from playwright._impl._file_chooser import normalize_file_payloads
 from playwright._impl._helper import (
     DocumentLoadState,
     FrameNavigatedEvent,
     KeyboardModifier,
     MouseButton,
+    TimeoutSettings,
     URLMatch,
-    URLMatcher,
-    is_function_body,
+    async_readfile,
     locals_to_params,
     monotonic_time,
+    url_matches,
 )
 from playwright._impl._js_handle import (
     JSHandle,
     Serializable,
+    add_source_url_to_script,
     parse_result,
+    parse_value,
     serialize_argument,
 )
+from playwright._impl._locator import (
+    FrameLocator,
+    Locator,
+    get_by_alt_text_selector,
+    get_by_label_selector,
+    get_by_placeholder_selector,
+    get_by_role_selector,
+    get_by_test_id_selector,
+    get_by_text_selector,
+    get_by_title_selector,
+    test_id_attribute_name,
+)
 from playwright._impl._network import Response
-from playwright._impl._wait_helper import WaitHelper
-
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import Literal
-else:  # pragma: no cover
-    from typing_extensions import Literal
+from playwright._impl._set_input_files_helpers import convert_input_files
+from playwright._impl._waiter import Waiter
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._page import Page
@@ -69,7 +98,7 @@ def __init__(
         self._url = initializer["url"]
         self._detached = False
         self._child_frames: List[Frame] = []
-        self._page: "Page"
+        self._page: Optional[Page] = None
         self._load_states: Set[str] = set(initializer["loadStates"])
         self._event_emitter = EventEmitter()
         self._channel.on(
@@ -81,6 +110,9 @@ def __init__(
             lambda params: self._on_frame_navigated(params),
         )
 
+    def __repr__(self) -> str:
+        return f"<Frame name={self.name} url={self.url!r}>"
+
     def _on_load_state(
         self, add: DocumentLoadState = None, remove: DocumentLoadState = None
     ) -> None:
@@ -89,218 +121,371 @@ def _on_load_state(
             self._event_emitter.emit("loadstate", add)
         elif remove and remove in self._load_states:
             self._load_states.remove(remove)
+        if not self._parent_frame and add == "load" and self._page:
+            self._page.emit("load", self._page)
+            self._page.context.emit("pageload", self._page)
+        if not self._parent_frame and add == "domcontentloaded" and self._page:
+            self._page.emit("domcontentloaded", self._page)
 
     def _on_frame_navigated(self, event: FrameNavigatedEvent) -> None:
         self._url = event["url"]
         self._name = event["name"]
         self._event_emitter.emit("navigated", event)
-        if "error" not in event and hasattr(self, "_page") and self._page:
+        if "error" not in event and self._page:
             self._page.emit("framenavigated", self)
+            self._page.context.emit("framenavigated", self)
+
+    async def _query_count(self, selector: str) -> int:
+        return await self._channel.send("queryCount", None, {"selector": selector})
 
     @property
     def page(self) -> "Page":
+        assert self._page
         return self._page
 
     async def goto(
         self,
         url: str,
-        timeout: int = None,
+        timeout: float = None,
         waitUntil: DocumentLoadState = None,
         referer: str = None,
     ) -> Optional[Response]:
         return cast(
             Optional[Response],
             from_nullable_channel(
-                await self._channel.send("goto", locals_to_params(locals()))
+                await self._channel.send(
+                    "goto", self._navigation_timeout, locals_to_params(locals())
+                )
             ),
         )
 
-    def _setup_navigation_wait_helper(self, timeout: int = None) -> WaitHelper:
-        wait_helper = WaitHelper(self._loop)
-        wait_helper.reject_on_event(
-            self._page, "close", Error("Navigation failed because page was closed!")
+    def _setup_navigation_waiter(self, wait_name: str, timeout: float = None) -> Waiter:
+        assert self._page
+        waiter = Waiter(self._page, f"frame.{wait_name}")
+        waiter.reject_on_event(
+            self._page,
+            "close",
+            lambda: cast("Page", self._page)._close_error_with_reason(),
         )
-        wait_helper.reject_on_event(
+        waiter.reject_on_event(
             self._page, "crash", Error("Navigation failed because page crashed!")
         )
-        wait_helper.reject_on_event(
+        waiter.reject_on_event(
             self._page,
             "framedetached",
             Error("Navigating frame was detached!"),
             lambda frame: frame == self,
         )
-        if timeout is None:
-            timeout = self._page._timeout_settings.navigation_timeout()
-        wait_helper.reject_on_timeout(timeout, f"Timeout {timeout}ms exceeded.")
-        return wait_helper
+        timeout = self._page._timeout_settings.navigation_timeout(timeout)
+        waiter.reject_on_timeout(timeout, f"Timeout {timeout}ms exceeded.")
+        return waiter
 
-    async def waitForNavigation(
+    async def _expect(
+        self,
+        selector: Optional[str],
+        expression: str,
+        options: FrameExpectOptions,
+        title: str = None,
+    ) -> FrameExpectResult:
+        if "expectedValue" in options:
+            options["expectedValue"] = serialize_argument(options["expectedValue"])
+        result = await self._channel.send_return_as_dict(
+            "expect",
+            self._timeout,
+            {
+                "selector": selector,
+                "expression": expression,
+                **options,
+            },
+            title=title,
+        )
+        if result.get("received"):
+            result["received"] = parse_value(result["received"])
+        return result
+
+    def expect_navigation(
         self,
         url: URLMatch = None,
         waitUntil: DocumentLoadState = None,
-        timeout: int = None,
-    ) -> Optional[Response]:
+        timeout: float = None,
+    ) -> EventContextManagerImpl[Response]:
+        assert self._page
         if not waitUntil:
             waitUntil = "load"
 
         if timeout is None:
             timeout = self._page._timeout_settings.navigation_timeout()
         deadline = monotonic_time() + timeout
-        wait_helper = self._setup_navigation_wait_helper(timeout)
-        matcher = URLMatcher(url) if url else None
+        waiter = self._setup_navigation_waiter("expect_navigation", timeout)
+
+        to_url = f' to "{url}"' if url else ""
+        waiter.log(f"waiting for navigation{to_url} until '{waitUntil}'")
 
         def predicate(event: Any) -> bool:
             # Any failed navigation results in a rejection.
             if event.get("error"):
                 return True
-            return not matcher or matcher.matches(event["url"])
+            waiter.log(f'  navigated to "{event["url"]}"')
+            return url_matches(
+                cast("Page", self._page)._browser_context._base_url,
+                event["url"],
+                url,
+            )
 
-        event = await wait_helper.wait_for_event(
+        waiter.wait_for_event(
             self._event_emitter,
             "navigated",
             predicate=predicate,
         )
-        if "error" in event:
-            raise Error(event["error"])
 
-        if waitUntil not in self._load_states:
-            t = deadline - monotonic_time()
-            if t > 0:
-                await self.waitForLoadState(state=waitUntil, timeout=t)
+        async def continuation() -> Optional[Response]:
+            event = await waiter.result()
+            if "error" in event:
+                raise Error(event["error"])
+            if waitUntil not in self._load_states:
+                t = deadline - monotonic_time()
+                if t > 0:
+                    await self._wait_for_load_state_impl(state=waitUntil, timeout=t)
+            if "newDocument" in event and "request" in event["newDocument"]:
+                request = from_channel(event["newDocument"]["request"])
+                return await request.response()
+            return None
+
+        return EventContextManagerImpl(asyncio.create_task(continuation()))
+
+    async def wait_for_url(
+        self,
+        url: URLMatch,
+        waitUntil: DocumentLoadState = None,
+        timeout: float = None,
+    ) -> None:
+        assert self._page
+        if url_matches(self._page._browser_context._base_url, self.url, url):
+            await self._wait_for_load_state_impl(state=waitUntil, timeout=timeout)
+            return
+        async with self.expect_navigation(
+            url=url, waitUntil=waitUntil, timeout=timeout
+        ):
+            pass
 
-        if "newDocument" in event and "request" in event["newDocument"]:
-            request = from_channel(event["newDocument"]["request"])
-            return await request.response()
-        return None
+    async def wait_for_load_state(
+        self,
+        state: Literal["domcontentloaded", "load", "networkidle"] = None,
+        timeout: float = None,
+    ) -> None:
+        return await self._wait_for_load_state_impl(state, timeout)
 
-    async def waitForLoadState(
-        self, state: DocumentLoadState = None, timeout: int = None
+    async def _wait_for_load_state_impl(
+        self, state: DocumentLoadState = None, timeout: float = None
     ) -> None:
         if not state:
             state = "load"
-        if state not in ("load", "domcontentloaded", "networkidle"):
-            raise Error("state: expected one of (load|domcontentloaded|networkidle)")
+        if state not in ("load", "domcontentloaded", "networkidle", "commit"):
+            raise Error(
+                "state: expected one of (load|domcontentloaded|networkidle|commit)"
+            )
+        waiter = self._setup_navigation_waiter("wait_for_load_state", timeout)
+
         if state in self._load_states:
-            return
-        wait_helper = self._setup_navigation_wait_helper(timeout)
-        await wait_helper.wait_for_event(
-            self._event_emitter, "loadstate", lambda s: s == state
+            waiter.log(f'  not waiting, "{state}" event already fired')
+            # TODO: align with upstream
+            waiter._fulfill(None)
+        else:
+
+            def handle_load_state_event(actual_state: str) -> bool:
+                waiter.log(f'"{actual_state}" event fired')
+                return actual_state == state
+
+            waiter.wait_for_event(
+                self._event_emitter,
+                "loadstate",
+                handle_load_state_event,
+            )
+        await waiter.result()
+
+    def _timeout(self, timeout: Optional[float]) -> float:
+        timeout_settings = (
+            self._page._timeout_settings if self._page else TimeoutSettings(None)
         )
+        return timeout_settings.timeout(timeout)
 
-    async def frameElement(self) -> ElementHandle:
-        return from_channel(await self._channel.send("frameElement"))
+    def _navigation_timeout(self, timeout: Optional[float]) -> float:
+        timeout_settings = (
+            self._page._timeout_settings if self._page else TimeoutSettings(None)
+        )
+        return timeout_settings.navigation_timeout(timeout)
 
-    async def evaluate(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
-    ) -> Any:
-        if not is_function_body(expression):
-            force_expr = True
+    async def frame_element(self) -> ElementHandle:
+        return from_channel(await self._channel.send("frameElement", None))
+
+    async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
         return parse_result(
             await self._channel.send(
                 "evaluateExpression",
+                None,
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
-    async def evaluateHandle(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
+    async def evaluate_handle(
+        self, expression: str, arg: Serializable = None
     ) -> JSHandle:
-        if not is_function_body(expression):
-            force_expr = True
         return from_channel(
             await self._channel.send(
                 "evaluateExpressionHandle",
+                None,
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
-    async def querySelector(self, selector: str) -> Optional[ElementHandle]:
+    async def query_selector(
+        self, selector: str, strict: bool = None
+    ) -> Optional[ElementHandle]:
         return from_nullable_channel(
-            await self._channel.send("querySelector", dict(selector=selector))
+            await self._channel.send("querySelector", None, locals_to_params(locals()))
         )
 
-    async def querySelectorAll(self, selector: str) -> List[ElementHandle]:
+    async def query_selector_all(self, selector: str) -> List[ElementHandle]:
         return list(
             map(
-                cast(ElementHandle, from_channel),
-                await self._channel.send("querySelectorAll", dict(selector=selector)),
+                from_channel,
+                await self._channel.send(
+                    "querySelectorAll", None, dict(selector=selector)
+                ),
             )
         )
 
-    async def waitForSelector(
+    async def wait_for_selector(
         self,
         selector: str,
-        timeout: int = None,
+        strict: bool = None,
+        timeout: float = None,
         state: Literal["attached", "detached", "hidden", "visible"] = None,
     ) -> Optional[ElementHandle]:
         return from_nullable_channel(
-            await self._channel.send("waitForSelector", locals_to_params(locals()))
+            await self._channel.send(
+                "waitForSelector", self._timeout, locals_to_params(locals())
+            )
         )
 
-    async def dispatchEvent(
-        self, selector: str, type: str, eventInit: Dict = None, timeout: int = None
+    async def is_checked(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._channel.send(
+            "isChecked", self._timeout, locals_to_params(locals())
+        )
+
+    async def is_disabled(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._channel.send(
+            "isDisabled", self._timeout, locals_to_params(locals())
+        )
+
+    async def is_editable(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._channel.send(
+            "isEditable", self._timeout, locals_to_params(locals())
+        )
+
+    async def is_enabled(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._channel.send(
+            "isEnabled", self._timeout, locals_to_params(locals())
+        )
+
+    async def is_hidden(self, selector: str, strict: bool = None) -> bool:
+        return await self._channel.send(
+            "isHidden", self._timeout, locals_to_params(locals())
+        )
+
+    async def is_visible(self, selector: str, strict: bool = None) -> bool:
+        return await self._channel.send(
+            "isVisible", self._timeout, locals_to_params(locals())
+        )
+
+    async def dispatch_event(
+        self,
+        selector: str,
+        type: str,
+        eventInit: Dict = None,
+        strict: bool = None,
+        timeout: float = None,
     ) -> None:
         await self._channel.send(
             "dispatchEvent",
-            dict(selector=selector, type=type, eventInit=serialize_argument(eventInit)),
+            self._timeout,
+            locals_to_params(
+                dict(
+                    selector=selector,
+                    type=type,
+                    eventInit=serialize_argument(eventInit),
+                    strict=strict,
+                    timeout=timeout,
+                ),
+            ),
         )
 
-    async def evalOnSelector(
+    async def eval_on_selector(
         self,
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
+        strict: bool = None,
     ) -> Any:
         return parse_result(
             await self._channel.send(
                 "evalOnSelector",
-                dict(
-                    selector=selector,
-                    expression=expression,
-                    isFunction=not (force_expr),
-                    arg=serialize_argument(arg),
+                None,
+                locals_to_params(
+                    dict(
+                        selector=selector,
+                        expression=expression,
+                        arg=serialize_argument(arg),
+                        strict=strict,
+                    )
                 ),
             )
         )
 
-    async def evalOnSelectorAll(
+    async def eval_on_selector_all(
         self,
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
     ) -> Any:
         return parse_result(
             await self._channel.send(
                 "evalOnSelectorAll",
+                None,
                 dict(
                     selector=selector,
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
     async def content(self) -> str:
-        return await self._channel.send("content")
+        return await self._channel.send("content", None)
 
-    async def setContent(
+    async def set_content(
         self,
         html: str,
-        timeout: int = None,
+        timeout: float = None,
         waitUntil: DocumentLoadState = None,
     ) -> None:
-        await self._channel.send("setContent", locals_to_params(locals()))
+        await self._channel.send(
+            "setContent", self._navigation_timeout, locals_to_params(locals())
+        )
 
     @property
     def name(self) -> str:
@@ -311,17 +496,17 @@ def url(self) -> str:
         return self._url or ""
 
     @property
-    def parentFrame(self) -> Optional["Frame"]:
+    def parent_frame(self) -> Optional["Frame"]:
         return self._parent_frame
 
     @property
-    def childFrames(self) -> List["Frame"]:
+    def child_frames(self) -> List["Frame"]:
         return self._child_frames.copy()
 
-    def isDetached(self) -> bool:
+    def is_detached(self) -> bool:
         return self._detached
 
-    async def addScriptTag(
+    async def add_script_tag(
         self,
         url: str = None,
         path: Union[str, Path] = None,
@@ -330,194 +515,438 @@ async def addScriptTag(
     ) -> ElementHandle:
         params = locals_to_params(locals())
         if path:
-            with open(path, "r") as file:
-                params["content"] = file.read() + "\n//# sourceURL=" + str(Path(path))
-                del params["path"]
-        return from_channel(await self._channel.send("addScriptTag", params))
+            params["content"] = add_source_url_to_script(
+                (await async_readfile(path)).decode(), path
+            )
+            del params["path"]
+        return from_channel(await self._channel.send("addScriptTag", None, params))
 
-    async def addStyleTag(
+    async def add_style_tag(
         self, url: str = None, path: Union[str, Path] = None, content: str = None
     ) -> ElementHandle:
         params = locals_to_params(locals())
         if path:
-            with open(path, "r") as file:
-                params["content"] = (
-                    file.read() + "\n/*# sourceURL=" + str(Path(path)) + "*/"
-                )
-                del params["path"]
-        return from_channel(await self._channel.send("addStyleTag", params))
+            params["content"] = (
+                (await async_readfile(path)).decode()
+                + "\n/*# sourceURL="
+                + str(Path(path))
+                + "*/"
+            )
+            del params["path"]
+        return from_channel(await self._channel.send("addStyleTag", None, params))
 
     async def click(
         self,
         selector: str,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        delay: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
         button: MouseButton = None,
         clickCount: int = None,
-        timeout: int = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
     ) -> None:
-        await self._channel.send("click", locals_to_params(locals()))
+        await self._click(**locals_to_params(locals()))
+
+    async def _click(
+        self,
+        selector: str,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
+        button: MouseButton = None,
+        clickCount: int = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+        steps: int = None,
+    ) -> None:
+        await self._channel.send("click", self._timeout, locals_to_params(locals()))
 
     async def dblclick(
         self,
         selector: str,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        delay: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
         button: MouseButton = None,
-        timeout: int = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
     ) -> None:
-        await self._channel.send("dblclick", locals_to_params(locals()))
+        await self._channel.send(
+            "dblclick", self._timeout, locals_to_params(locals()), title="Double click"
+        )
 
     async def tap(
         self,
         selector: str,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        timeout: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
     ) -> None:
-        await self._channel.send("tap", locals_to_params(locals()))
+        await self._channel.send("tap", self._timeout, locals_to_params(locals()))
 
     async def fill(
-        self, selector: str, value: str, timeout: int = None, noWaitAfter: bool = None
+        self,
+        selector: str,
+        value: str,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        force: bool = None,
+    ) -> None:
+        await self._fill(**locals_to_params(locals()))
+
+    async def _fill(
+        self,
+        selector: str,
+        value: str,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        force: bool = None,
+        title: str = None,
     ) -> None:
-        await self._channel.send("fill", locals_to_params(locals()))
+        await self._channel.send("fill", self._timeout, locals_to_params(locals()))
+
+    def locator(
+        self,
+        selector: str,
+        hasText: Union[str, Pattern[str]] = None,
+        hasNotText: Union[str, Pattern[str]] = None,
+        has: Locator = None,
+        hasNot: Locator = None,
+    ) -> Locator:
+        return Locator(
+            self,
+            selector,
+            has_text=hasText,
+            has_not_text=hasNotText,
+            has=has,
+            has_not=hasNot,
+        )
+
+    def get_by_alt_text(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_alt_text_selector(text, exact=exact))
+
+    def get_by_label(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_label_selector(text, exact=exact))
+
+    def get_by_placeholder(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_placeholder_selector(text, exact=exact))
 
-    async def focus(self, selector: str, timeout: int = None) -> None:
-        await self._channel.send("focus", locals_to_params(locals()))
+    def get_by_role(
+        self,
+        role: AriaRole,
+        checked: bool = None,
+        disabled: bool = None,
+        expanded: bool = None,
+        includeHidden: bool = None,
+        level: int = None,
+        name: Union[str, Pattern[str]] = None,
+        pressed: bool = None,
+        selected: bool = None,
+        exact: bool = None,
+        description: Union[str, Pattern[str]] = None,
+    ) -> "Locator":
+        return self.locator(
+            get_by_role_selector(
+                role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=includeHidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
+
+    def get_by_test_id(self, testId: Union[str, Pattern[str]]) -> "Locator":
+        return self.locator(get_by_test_id_selector(test_id_attribute_name(), testId))
+
+    def get_by_text(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_text_selector(text, exact=exact))
+
+    def get_by_title(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_title_selector(text, exact=exact))
+
+    def frame_locator(self, selector: str) -> FrameLocator:
+        return FrameLocator(self, selector)
+
+    async def focus(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> None:
+        await self._channel.send("focus", self._timeout, locals_to_params(locals()))
 
-    async def textContent(self, selector: str, timeout: int = None) -> Optional[str]:
-        return await self._channel.send("textContent", locals_to_params(locals()))
+    async def text_content(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> Optional[str]:
+        return await self._channel.send(
+            "textContent", self._timeout, locals_to_params(locals())
+        )
 
-    async def innerText(self, selector: str, timeout: int = None) -> str:
-        return await self._channel.send("innerText", locals_to_params(locals()))
+    async def inner_text(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> str:
+        return await self._channel.send(
+            "innerText", self._timeout, locals_to_params(locals())
+        )
 
-    async def innerHTML(self, selector: str, timeout: int = None) -> str:
-        return await self._channel.send("innerHTML", locals_to_params(locals()))
+    async def inner_html(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> str:
+        return await self._channel.send(
+            "innerHTML", self._timeout, locals_to_params(locals())
+        )
 
-    async def getAttribute(
-        self, selector: str, name: str, timeout: int = None
+    async def get_attribute(
+        self, selector: str, name: str, strict: bool = None, timeout: float = None
     ) -> Optional[str]:
-        return await self._channel.send("getAttribute", locals_to_params(locals()))
+        return await self._channel.send(
+            "getAttribute", self._timeout, locals_to_params(locals())
+        )
 
     async def hover(
         self,
         selector: str,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        timeout: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        force: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+    ) -> None:
+        await self._channel.send("hover", self._timeout, locals_to_params(locals()))
+
+    async def drag_and_drop(
+        self,
+        source: str,
+        target: str,
+        sourcePosition: Position = None,
+        targetPosition: Position = None,
         force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        timeout: float = None,
+        trial: bool = None,
+        steps: int = None,
     ) -> None:
-        await self._channel.send("hover", locals_to_params(locals()))
+        await self._channel.send(
+            "dragAndDrop", self._timeout, locals_to_params(locals())
+        )
 
-    async def selectOption(
+    async def select_option(
         self,
         selector: str,
-        value: Union[str, List[str]] = None,
-        index: Union[int, List[int]] = None,
-        label: Union[str, List[str]] = None,
-        element: Union["ElementHandle", List["ElementHandle"]] = None,
-        timeout: int = None,
+        value: Union[str, Sequence[str]] = None,
+        index: Union[int, Sequence[int]] = None,
+        label: Union[str, Sequence[str]] = None,
+        element: Union["ElementHandle", Sequence["ElementHandle"]] = None,
+        timeout: float = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
+        force: bool = None,
     ) -> List[str]:
         params = locals_to_params(
             dict(
                 selector=selector,
                 timeout=timeout,
-                noWaitAfter=noWaitAfter,
+                strict=strict,
+                force=force,
                 **convert_select_option_values(value, index, label, element),
             )
         )
-        return await self._channel.send("selectOption", params)
+        return await self._channel.send("selectOption", self._timeout, params)
+
+    async def input_value(
+        self,
+        selector: str,
+        strict: bool = None,
+        timeout: float = None,
+    ) -> str:
+        return await self._channel.send(
+            "inputValue", self._timeout, locals_to_params(locals())
+        )
 
-    async def setInputFiles(
+    async def set_input_files(
         self,
         selector: str,
-        files: Union[str, Path, FilePayload, List[str], List[Path], List[FilePayload]],
-        timeout: int = None,
+        files: Union[
+            str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
+        ],
+        strict: bool = None,
+        timeout: float = None,
         noWaitAfter: bool = None,
     ) -> None:
-        params = locals_to_params(locals())
-        params["files"] = normalize_file_payloads(files)
-        await self._channel.send("setInputFiles", params)
+        converted = await convert_input_files(files, self.page.context)
+        await self._channel.send(
+            "setInputFiles",
+            self._timeout,
+            {
+                "selector": selector,
+                "strict": strict,
+                "timeout": self._timeout(timeout),
+                **converted,
+            },
+        )
+
+    async def _drop(
+        self,
+        selector: str,
+        payload: "DropPayload",
+        strict: bool = None,
+        position: Position = None,
+        timeout: float = None,
+    ) -> None:
+        params: Dict[str, Any] = {
+            "selector": selector,
+            "strict": strict,
+            "position": position,
+            "timeout": self._timeout(timeout),
+        }
+        files = payload.get("files") if payload else None
+        if files is not None:
+            converted = await convert_input_files(files, self.page.context)
+            if "directoryStream" in converted or "directoryLocalPath" in converted:
+                raise Error(
+                    "Dropping a directory is not supported, pass individual files instead."
+                )
+            params.update(converted)
+        data = payload.get("data") if payload else None
+        if data is not None:
+            params["data"] = [{"mimeType": k, "value": v} for k, v in data.items()]
+        await self._channel.send("drop", self._timeout, params)
 
     async def type(
         self,
         selector: str,
         text: str,
-        delay: int = None,
-        timeout: int = None,
+        delay: float = None,
+        strict: bool = None,
+        timeout: float = None,
         noWaitAfter: bool = None,
     ) -> None:
-        await self._channel.send("type", locals_to_params(locals()))
+        await self._channel.send("type", self._timeout, locals_to_params(locals()))
 
     async def press(
         self,
         selector: str,
         key: str,
-        delay: int = None,
-        timeout: int = None,
+        delay: float = None,
+        strict: bool = None,
+        timeout: float = None,
         noWaitAfter: bool = None,
     ) -> None:
-        await self._channel.send("press", locals_to_params(locals()))
+        await self._channel.send("press", self._timeout, locals_to_params(locals()))
 
     async def check(
         self,
         selector: str,
-        timeout: int = None,
+        position: Position = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
     ) -> None:
-        await self._channel.send("check", locals_to_params(locals()))
+        await self._channel.send("check", self._timeout, locals_to_params(locals()))
 
     async def uncheck(
         self,
         selector: str,
-        timeout: int = None,
+        position: Position = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
     ) -> None:
-        await self._channel.send("uncheck", locals_to_params(locals()))
+        await self._channel.send("uncheck", self._timeout, locals_to_params(locals()))
 
-    async def waitForTimeout(self, timeout: int) -> None:
-        await self._connection._loop.create_task(asyncio.sleep(timeout / 1000))
+    async def wait_for_timeout(self, timeout: float) -> None:
+        await self._channel.send("waitForTimeout", None, {"waitTimeout": timeout})
 
-    async def waitForFunction(
+    async def wait_for_function(
         self,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
-        timeout: int = None,
-        polling: Union[int, Literal["raf"]] = None,
+        timeout: float = None,
+        polling: Union[float, Literal["raf"]] = None,
     ) -> JSHandle:
-        if not is_function_body(expression):
-            force_expr = True
+        if isinstance(polling, str) and polling != "raf":
+            raise Error(f"Unknown polling option: {polling}")
         params = locals_to_params(locals())
-        params["isFunction"] = not (force_expr)
         params["arg"] = serialize_argument(arg)
-        return from_channel(await self._channel.send("waitForFunction", params))
+        if polling is not None and polling != "raf":
+            params["pollingInterval"] = polling
+        return from_channel(
+            await self._channel.send("waitForFunction", self._timeout, params)
+        )
 
     async def title(self) -> str:
-        return await self._channel.send("title")
+        return await self._channel.send("title", None)
 
-    def expect_load_state(
+    async def set_checked(
         self,
-        state: DocumentLoadState = None,
-        timeout: int = None,
-    ) -> EventContextManagerImpl[Optional[Response]]:
-        return EventContextManagerImpl(self.waitForLoadState(state, timeout))
+        selector: str,
+        checked: bool,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+    ) -> None:
+        if checked:
+            await self.check(
+                selector=selector,
+                position=position,
+                timeout=timeout,
+                force=force,
+                strict=strict,
+                trial=trial,
+            )
+        else:
+            await self.uncheck(
+                selector=selector,
+                position=position,
+                timeout=timeout,
+                force=force,
+                strict=strict,
+                trial=trial,
+            )
 
-    def expect_navigation(
-        self,
-        url: URLMatch = None,
-        waitUntil: DocumentLoadState = None,
-        timeout: int = None,
-    ) -> EventContextManagerImpl[Optional[Response]]:
-        return EventContextManagerImpl(self.waitForNavigation(url, waitUntil, timeout))
+    async def _highlight(self, selector: str, style: str = None) -> None:
+        await self._channel.send(
+            "highlight", None, {"selector": selector, "style": style}
+        )
+
+    async def _hide_highlight(self, selector: str) -> None:
+        await self._channel.send("hideHighlight", None, {"selector": selector})
diff --git a/playwright/_impl/_glob.py b/playwright/_impl/_glob.py
new file mode 100644
index 000000000..b38826996
--- /dev/null
+++ b/playwright/_impl/_glob.py
@@ -0,0 +1,65 @@
+# 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.
+
+#  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions#escaping
+escaped_chars = {"$", "^", "+", ".", "*", "(", ")", "|", "\\", "?", "{", "}", "[", "]"}
+
+
+def glob_to_regex_pattern(glob: str) -> str:
+    tokens = ["^"]
+    in_group = False
+
+    i = 0
+    while i < len(glob):
+        c = glob[i]
+        if c == "\\" and i + 1 < len(glob):
+            char = glob[i + 1]
+            tokens.append("\\" + char if char in escaped_chars else char)
+            i += 1
+        elif c == "*":
+            char_before = glob[i - 1] if i > 0 else None
+            star_count = 1
+            while i + 1 < len(glob) and glob[i + 1] == "*":
+                star_count += 1
+                i += 1
+            if star_count > 1:
+                char_after = glob[i + 1] if i + 1 < len(glob) else None
+                if char_after == "/":
+                    if char_before == "/":
+                        tokens.append("((.+/)|)")
+                    else:
+                        tokens.append("(.*/)")
+                    i += 1
+                else:
+                    tokens.append("(.*)")
+            else:
+                tokens.append("([^/]*)")
+        else:
+            if c == "{":
+                in_group = True
+                tokens.append("(")
+            elif c == "}":
+                in_group = False
+                tokens.append(")")
+            elif c == ",":
+                if in_group:
+                    tokens.append("|")
+                else:
+                    tokens.append("\\" + c)
+            else:
+                tokens.append("\\" + c if c in escaped_chars else c)
+        i += 1
+
+    tokens.append("$")
+    return "".join(tokens)
diff --git a/playwright/_impl/_greenlets.py b/playwright/_impl/_greenlets.py
new file mode 100644
index 000000000..a381e6e53
--- /dev/null
+++ b/playwright/_impl/_greenlets.py
@@ -0,0 +1,49 @@
+# 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 os
+from typing import Tuple
+
+import greenlet
+
+
+def _greenlet_trace_callback(
+    event: str, args: Tuple[greenlet.greenlet, greenlet.greenlet]
+) -> None:
+    if event in ("switch", "throw"):
+        origin, target = args
+        print(f"Transfer from {origin} to {target} with {event}")
+
+
+if os.environ.get("INTERNAL_PW_GREENLET_DEBUG"):
+    greenlet.settrace(_greenlet_trace_callback)
+
+
+class MainGreenlet(greenlet.greenlet):
+    def __str__(self) -> str:
+        return "<MainGreenlet>"
+
+
+class RouteGreenlet(greenlet.greenlet):
+    def __str__(self) -> str:
+        return "<RouteGreenlet>"
+
+
+class LocatorHandlerGreenlet(greenlet.greenlet):
+    def __str__(self) -> str:
+        return "<LocatorHandlerGreenlet>"
+
+
+class EventGreenlet(greenlet.greenlet):
+    def __str__(self) -> str:
+        return "<EventGreenlet>"
diff --git a/playwright/_impl/_har_router.py b/playwright/_impl/_har_router.py
new file mode 100644
index 000000000..1fa1b0433
--- /dev/null
+++ b/playwright/_impl/_har_router.py
@@ -0,0 +1,122 @@
+# 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 asyncio
+import base64
+from typing import TYPE_CHECKING, Optional, cast
+
+from playwright._impl._api_structures import HeadersArray
+from playwright._impl._helper import (
+    HarLookupResult,
+    RouteFromHarNotFoundPolicy,
+    URLMatch,
+)
+from playwright._impl._local_utils import LocalUtils
+
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._browser_context import BrowserContext
+    from playwright._impl._network import Route
+    from playwright._impl._page import Page
+
+
+class HarRouter:
+    def __init__(
+        self,
+        local_utils: LocalUtils,
+        har_id: str,
+        not_found_action: RouteFromHarNotFoundPolicy,
+        url_matcher: Optional[URLMatch] = None,
+    ) -> None:
+        self._local_utils: LocalUtils = local_utils
+        self._har_id: str = har_id
+        self._not_found_action: RouteFromHarNotFoundPolicy = not_found_action
+        self._options_url_match: Optional[URLMatch] = url_matcher
+
+    @staticmethod
+    async def create(
+        local_utils: LocalUtils,
+        file: str,
+        not_found_action: RouteFromHarNotFoundPolicy,
+        url_matcher: Optional[URLMatch] = None,
+    ) -> "HarRouter":
+        har_id = await local_utils._channel.send("harOpen", None, {"file": file})
+        return HarRouter(
+            local_utils=local_utils,
+            har_id=har_id,
+            not_found_action=not_found_action,
+            url_matcher=url_matcher,
+        )
+
+    async def _handle(self, route: "Route") -> None:
+        request = route.request
+        response: HarLookupResult = await self._local_utils.har_lookup(
+            harId=self._har_id,
+            url=request.url,
+            method=request.method,
+            headers=await request.headers_array(),
+            postData=request.post_data_buffer,
+            isNavigationRequest=request.is_navigation_request(),
+        )
+        action = response["action"]
+        if action == "redirect":
+            redirect_url = response["redirectURL"]
+            assert redirect_url
+            await route._redirected_navigation_request(redirect_url)
+            return
+
+        if action == "fulfill":
+            # If the response status is -1, the request was canceled or stalled, so we just stall it here.
+            # See https://github.com/microsoft/playwright/issues/29311.
+            # TODO: it'd be better to abort such requests, but then we likely need to respect the timing,
+            # because the request might have been stalled for a long time until the very end of the
+            # test when HAR was recorded but we'd abort it immediately.
+            if response.get("status") == -1:
+                return
+            body = response["body"]
+            assert body is not None
+            await route.fulfill(
+                status=response.get("status"),
+                headers={
+                    v["name"]: v["value"]
+                    for v in cast(HeadersArray, response.get("headers", []))
+                },
+                body=base64.b64decode(body),
+            )
+            return
+
+        if action == "error":
+            pass
+        # Report the error, but fall through to the default handler.
+
+        if self._not_found_action == "abort":
+            await route.abort()
+            return
+
+        await route.fallback()
+
+    async def add_context_route(self, context: "BrowserContext") -> None:
+        await context.route(
+            url=self._options_url_match or "**/*",
+            handler=lambda route, _: asyncio.create_task(self._handle(route)),
+        )
+
+    async def add_page_route(self, page: "Page") -> None:
+        await page.route(
+            url=self._options_url_match or "**/*",
+            handler=lambda route, _: asyncio.create_task(self._handle(route)),
+        )
+
+    def dispose(self) -> None:
+        asyncio.create_task(
+            self._local_utils._channel.send("harClose", None, {"harId": self._har_id})
+        )
diff --git a/playwright/_impl/_helper.py b/playwright/_impl/_helper.py
index e88949e01..213fdc1e3 100644
--- a/playwright/_impl/_helper.py
+++ b/playwright/_impl/_helper.py
@@ -11,64 +11,114 @@
 # 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 asyncio
-import fnmatch
+import datetime
 import math
+import os
 import re
-import sys
 import time
 import traceback
+from pathlib import Path
 from types import TracebackType
 from typing import (
     TYPE_CHECKING,
     Any,
+    Awaitable,
     Callable,
     Dict,
     List,
+    Literal,
     Optional,
     Pattern,
+    Set,
+    Tuple,
+    TypedDict,
+    TypeVar,
     Union,
     cast,
 )
-
-from playwright._impl._api_types import Error, TimeoutError
-
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import Literal, TypedDict
-else:  # pragma: no cover
-    from typing_extensions import Literal, TypedDict
-
+from urllib.parse import ParseResult, urljoin, urlparse, urlunparse
+
+from playwright._impl._api_structures import NameValue
+from playwright._impl._errors import (
+    Error,
+    TargetClosedError,
+    TimeoutError,
+    is_target_closed_error,
+    rewrite_error,
+)
+from playwright._impl._glob import glob_to_regex_pattern
+from playwright._impl._greenlets import RouteGreenlet
+from playwright._impl._str_utils import escape_regex_flags
 
 if TYPE_CHECKING:  # pragma: no cover
-    from playwright._impl._network import Request, Route
-
-URLMatch = Union[str, Pattern, Callable[[str], bool]]
-RouteHandler = Union[Callable[["Route"], Any], Callable[["Route", "Request"], Any]]
-
-ColorScheme = Literal["dark", "light", "no-preference"]
-DocumentLoadState = Literal["domcontentloaded", "load", "networkidle"]
-KeyboardModifier = Literal["Alt", "Control", "Meta", "Shift"]
+    from playwright._impl._api_structures import HeadersArray
+    from playwright._impl._network import Request, Response, Route, WebSocketRoute
+
+URLMatch = Union[str, Pattern[str], Callable[[str], bool]]
+URLMatchRequest = Union[
+    str, Pattern[str], Callable[["Request"], Union[bool, Awaitable[bool]]]
+]
+URLMatchResponse = Union[
+    str, Pattern[str], Callable[["Response"], Union[bool, Awaitable[bool]]]
+]
+RouteHandlerCallback = Union[
+    Callable[["Route"], Any], Callable[["Route", "Request"], Any]
+]
+WebSocketRouteHandlerCallback = Callable[["WebSocketRoute"], Any]
+
+ColorScheme = Literal["dark", "light", "no-preference", "null"]
+ForcedColors = Literal["active", "none", "null"]
+Contrast = Literal["more", "no-preference", "null"]
+ReducedMotion = Literal["no-preference", "null", "reduce"]
+DocumentLoadState = Literal["commit", "domcontentloaded", "load", "networkidle"]
+KeyboardModifier = Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]
 MouseButton = Literal["left", "middle", "right"]
+ServiceWorkersPolicy = Literal["allow", "block"]
+HarMode = Literal["full", "minimal"]
+HarContentPolicy = Literal["attach", "embed", "omit"]
+RouteFromHarNotFoundPolicy = Literal["abort", "fallback"]
 
 
 class ErrorPayload(TypedDict, total=False):
     message: str
     name: str
     stack: str
-    value: Any
-
-
-class Header(TypedDict):
-    name: str
-    value: str
-
-
-class ContinueParameters(TypedDict, total=False):
-    url: Optional[str]
-    method: Optional[str]
-    headers: Optional[List[Header]]
-    postData: Optional[str]
+    value: Optional[Any]
+
+
+class HarRecordingMetadata(TypedDict, total=False):
+    path: str
+    content: Optional[HarContentPolicy]
+
+
+def prepare_record_har_options(params: Dict) -> Dict[str, Any]:
+    out_params: Dict[str, Any] = {"path": str(params["recordHarPath"])}
+    if "recordHarUrlFilter" in params:
+        opt = params["recordHarUrlFilter"]
+        if isinstance(opt, str):
+            out_params["urlGlob"] = opt
+        if isinstance(opt, Pattern):
+            out_params["urlRegexSource"] = opt.pattern
+            out_params["urlRegexFlags"] = escape_regex_flags(opt)
+        del params["recordHarUrlFilter"]
+    if "recordHarMode" in params:
+        out_params["mode"] = params["recordHarMode"]
+        del params["recordHarMode"]
+
+    new_content_api = None
+    old_content_api = None
+    if "recordHarContent" in params:
+        new_content_api = params["recordHarContent"]
+        del params["recordHarContent"]
+    if "recordHarOmitContent" in params:
+        old_content_api = params["recordHarOmitContent"]
+        del params["recordHarOmitContent"]
+    content = new_content_api or ("omit" if old_content_api else None)
+    if content:
+        out_params["content"] = content
+
+    return out_params
 
 
 class ParsedMessageParams(TypedDict):
@@ -97,99 +147,241 @@ class FrameNavigatedEvent(TypedDict):
     error: Optional[str]
 
 
-Env = Dict[str, Union[str, int, bool]]
+Env = Dict[str, Union[str, float, bool]]
 
 
-class URLMatcher:
-    def __init__(self, match: URLMatch) -> None:
-        self._callback: Optional[Callable[[str], bool]] = None
-        self._regex_obj: Optional[Pattern] = None
-        if isinstance(match, str):
-            regex = fnmatch.translate(match)
-            self._regex_obj = re.compile(regex)
-        elif isinstance(match, Pattern):
-            self._regex_obj = match
+def url_matches(
+    base_url: Optional[str],
+    url_string: str,
+    match: Optional[URLMatch],
+    websocket_url: bool = None,
+) -> bool:
+    if not match:
+        return True
+    if isinstance(match, str):
+        match = re.compile(
+            resolve_glob_to_regex_pattern(base_url, match, websocket_url)
+        )
+    if isinstance(match, Pattern):
+        return bool(match.search(url_string))
+    return match(url_string)
+
+
+def resolve_glob_to_regex_pattern(
+    base_url: Optional[str], glob: str, websocket_url: bool = None
+) -> str:
+    if websocket_url:
+        base_url = to_websocket_base_url(base_url)
+    glob = resolve_glob_base(base_url, glob)
+    return glob_to_regex_pattern(glob)
+
+
+def to_websocket_base_url(base_url: Optional[str]) -> Optional[str]:
+    if base_url is not None and re.match(r"^https?://", base_url):
+        base_url = re.sub(r"^http", "ws", base_url)
+    return base_url
+
+
+def resolve_glob_base(base_url: Optional[str], match: str) -> str:
+    if match[0] == "*":
+        return match
+
+    token_map: Dict[str, str] = {}
+
+    def map_token(original: str, replacement: str) -> str:
+        if len(original) == 0:
+            return ""
+        token_map[replacement] = original
+        return replacement
+
+    # Escaped `\\?` behaves the same as `?` in our glob patterns.
+    match = match.replace(r"\\?", "?")
+    # Special case about: URLs as they are not relative to base_url
+    if (
+        match.startswith("about:")
+        or match.startswith("data:")
+        or match.startswith("chrome:")
+        or match.startswith("edge:")
+        or match.startswith("file:")
+    ):
+        # about: and data: URLs are not relative to base_url, so we return them as is.
+        return match
+    # Glob symbols may be escaped in the URL and some of them such as ? affect resolution,
+    # so we replace them with safe components first.
+    processed_parts = []
+    for index, token in enumerate(match.split("/")):
+        if token in (".", "..", ""):
+            processed_parts.append(token)
+            continue
+        # Handle special case of http*://, note that the new schema has to be
+        # a web schema so that slashes are properly inserted after domain.
+        if index == 0 and token.endswith(":"):
+            # Replace any pattern with http:
+            if "*" in token or "{" in token:
+                processed_parts.append(map_token(token, "http:"))
+            else:
+                # Preserve explicit schema as is as it may affect trailing slashes after domain.
+                processed_parts.append(token)
+            continue
+        question_index = token.find("?")
+        if question_index == -1:
+            processed_parts.append(map_token(token, f"$_{index}_$"))
         else:
-            self._callback = match
-        self.match = match
+            new_prefix = map_token(token[:question_index], f"$_{index}_$")
+            new_suffix = map_token(token[question_index:], f"?$_{index}_$")
+            processed_parts.append(new_prefix + new_suffix)
+
+    relative_path = "/".join(processed_parts)
+    resolved, case_insensitive_part = resolve_base_url(base_url, relative_path)
+
+    for token, original in token_map.items():
+        normalize = case_insensitive_part and token in case_insensitive_part
+        resolved = resolved.replace(
+            token, original.lower() if normalize else original, 1
+        )
 
-    def matches(self, url: str) -> bool:
-        if self._callback:
-            return self._callback(url)
-        if self._regex_obj:
-            return cast(bool, self._regex_obj.search(url))
-        return False
+    return resolved
+
+
+def resolve_base_url(
+    base_url: Optional[str], given_url: str
+) -> Tuple[str, Optional[str]]:
+    try:
+        url = nodelike_urlparse(
+            urljoin(base_url if base_url is not None else "", given_url)
+        )
+        resolved = urlunparse(url)
+        # Schema and domain are case-insensitive.
+        hostname_port = (
+            url.hostname or ""
+        )  # can't use parsed.netloc because it includes userinfo (username:password)
+        if url.port:
+            hostname_port += f":{url.port}"
+        case_insensitive_prefix = f"{url.scheme}://{hostname_port}"
+        return resolved, case_insensitive_prefix
+    except Exception:
+        return given_url, None
+
+
+def nodelike_urlparse(url: str) -> ParseResult:
+    parsed = urlparse(url, allow_fragments=True)
+
+    # https://url.spec.whatwg.org/#special-scheme
+    is_special_url = parsed.scheme in ["http", "https", "ws", "wss", "ftp", "file"]
+    if is_special_url:
+        # special urls have a list path, list paths are serialized as follows: https://url.spec.whatwg.org/#url-path-serializer
+        # urllib diverges, so we patch it here
+        if parsed.path == "":
+            parsed = parsed._replace(path="/")
+
+    return parsed
+
+
+class HarLookupResult(TypedDict, total=False):
+    action: Literal["error", "redirect", "fulfill", "noentry"]
+    message: Optional[str]
+    redirectURL: Optional[str]
+    status: Optional[int]
+    headers: Optional["HeadersArray"]
+    body: Optional[str]
+
+
+DEFAULT_PLAYWRIGHT_TIMEOUT_IN_MILLISECONDS = 30000
+DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT_IN_MILLISECONDS = 180000
+PLAYWRIGHT_MAX_DEADLINE = 2147483647  # 2^31-1
 
 
 class TimeoutSettings:
+
+    @staticmethod
+    def launch_timeout(timeout: Optional[float] = None) -> float:
+        return (
+            timeout
+            if timeout is not None
+            else DEFAULT_PLAYWRIGHT_LAUNCH_TIMEOUT_IN_MILLISECONDS
+        )
+
     def __init__(self, parent: Optional["TimeoutSettings"]) -> None:
         self._parent = parent
-        self._timeout = 30000
-        self._navigation_timeout = 30000
+        self._default_timeout: Optional[float] = None
+        self._default_navigation_timeout: Optional[float] = None
 
-    def set_timeout(self, timeout: int) -> None:
-        self._timeout = timeout
+    def set_default_timeout(self, timeout: Optional[float]) -> None:
+        self._default_timeout = timeout
 
-    def timeout(self) -> int:
-        if self._timeout is not None:
-            return self._timeout
+    def timeout(self, timeout: float = None) -> float:
+        if timeout is not None:
+            return timeout
+        if self._default_timeout is not None:
+            return self._default_timeout
         if self._parent:
             return self._parent.timeout()
-        return 30000
-
-    def set_navigation_timeout(self, navigation_timeout: int) -> None:
-        self._navigation_timeout = navigation_timeout
-
-    def navigation_timeout(self) -> int:
-        if self._navigation_timeout is not None:
-            return self._navigation_timeout
+        return DEFAULT_PLAYWRIGHT_TIMEOUT_IN_MILLISECONDS
+
+    def set_default_navigation_timeout(
+        self, navigation_timeout: Optional[float]
+    ) -> None:
+        self._default_navigation_timeout = navigation_timeout
+
+    def default_navigation_timeout(self) -> Optional[float]:
+        return self._default_navigation_timeout
+
+    def default_timeout(self) -> Optional[float]:
+        return self._default_timeout
+
+    def navigation_timeout(self, timeout: float = None) -> float:
+        if timeout is not None:
+            return timeout
+        if self._default_navigation_timeout is not None:
+            return self._default_navigation_timeout
+        if self._default_timeout is not None:
+            return self._default_timeout
         if self._parent:
             return self._parent.navigation_timeout()
-        return 30000
+        return DEFAULT_PLAYWRIGHT_TIMEOUT_IN_MILLISECONDS
 
 
 def serialize_error(ex: Exception, tb: Optional[TracebackType]) -> ErrorPayload:
-    return dict(message=str(ex), stack="".join(traceback.format_tb(tb)))
+    return ErrorPayload(
+        message=str(ex), name="Error", stack="".join(traceback.format_tb(tb))
+    )
 
 
-def parse_error(error: ErrorPayload) -> Error:
+def parse_error(error: ErrorPayload, log: Optional[str] = None) -> Error:
     base_error_class = Error
     if error.get("name") == "TimeoutError":
         base_error_class = TimeoutError
-    return base_error_class(
-        cast(str, patch_error_message(error.get("message"))), error["stack"]
-    )
+    if error.get("name") == "TargetClosedError":
+        base_error_class = TargetClosedError
+    if not log:
+        log = ""
+    exc = base_error_class(patch_error_message(error["message"]) + log)
+    exc._name = error["name"]
+    exc._stack = error["stack"]
+    return exc
 
 
-def patch_error_message(message: Optional[str]) -> Optional[str]:
-    if not message:
-        return None
-
+def patch_error_message(message: str) -> str:
     match = re.match(r"(\w+)(: expected .*)", message)
     if match:
         message = to_snake_case(match.group(1)) + match.group(2)
     message = message.replace(
-        "Pass { acceptDownloads: true }", "Pass { accept_downloads: True }"
+        "Pass { acceptDownloads: true }", "Pass 'accept_downloads=True'"
     )
     return message
 
 
-def is_function_body(expression: str) -> bool:
-    expression = expression.strip()
-    return (
-        expression.startswith("function")
-        or expression.startswith("async ")
-        or "=>" in expression
-    )
-
-
 def locals_to_params(args: Dict) -> Dict:
     copy = {}
     for key in args:
         if key == "self":
             continue
         if args[key] is not None:
-            copy[key] = args[key]
+            copy[key] = (
+                args[key]
+                if not isinstance(args[key], Dict)
+                else locals_to_params(args[key])
+            )
     return copy
 
 
@@ -197,54 +389,199 @@ def monotonic_time() -> int:
     return math.floor(time.monotonic() * 1000)
 
 
-class PendingWaitEvent:
+class RouteHandlerInvocation:
+    complete: "asyncio.Future"
+    route: "Route"
+
+    def __init__(self, complete: "asyncio.Future", route: "Route") -> None:
+        self.complete = complete
+        self.route = route
+
+
+class RouteHandler:
     def __init__(
-        self, event: str, future: asyncio.Future, timeout_future: asyncio.Future
+        self,
+        base_url: Optional[str],
+        url: URLMatch,
+        handler: RouteHandlerCallback,
+        is_sync: bool,
+        times: Optional[int] = None,
     ):
-        self.event = event
-        self.future = future
-        self.timeout_future = timeout_future
-
-    def reject(self, is_crash: bool, target: str) -> None:
-        self.timeout_future.cancel()
-        if self.event == "close" and not is_crash:
-            return
-        if self.event == "crash" and is_crash:
-            return
-        self.future.set_exception(
-            Error(f"{target} crashed" if is_crash else f"{target} closed")
+        self._base_url = base_url
+        self.url = url
+        self.handler = handler
+        self._times = times if times else math.inf
+        self._handled_count = 0
+        self._is_sync = is_sync
+        self._ignore_exception = False
+        self._active_invocations: Set[RouteHandlerInvocation] = set()
+
+    def matches(self, request_url: str) -> bool:
+        return url_matches(self._base_url, request_url, self.url)
+
+    async def handle(self, route: "Route") -> bool:
+        handler_invocation = RouteHandlerInvocation(
+            asyncio.get_running_loop().create_future(), route
         )
+        self._active_invocations.add(handler_invocation)
+        try:
+            return await self._handle_internal(route)
+        except Exception as e:
+            # If the handler was stopped (without waiting for completion), we ignore all exceptions.
+            if self._ignore_exception:
+                return False
+            if is_target_closed_error(e):
+                # We are failing in the handler because the target has closed.
+                # Give user a hint!
+                optional_async_prefix = "await " if not self._is_sync else ""
+                raise rewrite_error(
+                    e,
+                    f"\"{str(e)}\" while running route callback.\nConsider awaiting `{optional_async_prefix}page.unroute_all(behavior='ignoreErrors')`\nbefore the end of the test to ignore remaining routes in flight.",
+                )
+            raise e
+        finally:
+            handler_invocation.complete.set_result(None)
+            self._active_invocations.remove(handler_invocation)
+
+    async def _handle_internal(self, route: "Route") -> bool:
+        handled_future = route._start_handling()
+
+        self._handled_count += 1
+        if self._is_sync:
+            handler_finished_future = route._loop.create_future()
+
+            def _handler() -> None:
+                try:
+                    self.handler(route, route.request)  # type: ignore
+                    handler_finished_future.set_result(None)
+                except Exception as e:
+                    handler_finished_future.set_exception(e)
+
+            # As with event handlers, each route handler is a potentially blocking context
+            # so it needs a fiber.
+            g = RouteGreenlet(_handler)
+            g.switch()
+            await handler_finished_future
+        else:
+            coro_or_future = self.handler(route, route.request)  # type: ignore
+            if coro_or_future:
+                # separate task so that we get a proper stack trace for exceptions / tracing api_name extraction
+                await asyncio.ensure_future(coro_or_future)
+        return await handled_future
+
+    async def stop(self, behavior: Literal["ignoreErrors", "wait"]) -> None:
+        # When a handler is manually unrouted or its page/context is closed we either
+        # - wait for the current handler invocations to finish
+        # - or do not wait, if the user opted out of it, but swallow all exceptions
+        #   that happen after the unroute/close.
+        if behavior == "ignoreErrors":
+            self._ignore_exception = True
+        else:
+            tasks = []
+            for activation in self._active_invocations:
+                if not activation.route._did_throw:
+                    tasks.append(activation.complete)
+            await asyncio.gather(*tasks)
+
+    @property
+    def will_expire(self) -> bool:
+        return self._handled_count + 1 >= self._times
+
+    @staticmethod
+    def prepare_interception_patterns(
+        handlers: List["RouteHandler"],
+    ) -> List[Dict[str, str]]:
+        patterns = []
+        all = False
+        for handler in handlers:
+            if isinstance(handler.url, str):
+                patterns.append({"glob": handler.url})
+            elif isinstance(handler.url, re.Pattern):
+                patterns.append(
+                    {
+                        "regexSource": handler.url.pattern,
+                        "regexFlags": escape_regex_flags(handler.url),
+                    }
+                )
+            else:
+                all = True
+        if all:
+            return [{"glob": "**/*"}]
+        return patterns
 
 
-class RouteHandlerEntry:
-    def __init__(self, matcher: URLMatcher, handler: RouteHandler):
-        self.matcher = matcher
-        self.handler = handler
+to_snake_case_regex = re.compile("((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))")
 
 
-def is_safe_close_error(error: Exception) -> bool:
-    message = str(error)
-    return message.endswith("Browser has been closed") or message.endswith(
-        "Target page, context or browser has been closed"
-    )
+def to_snake_case(name: str) -> str:
+    return to_snake_case_regex.sub(r"_\1", name).lower()
+
+
+def make_dirs_for_file(path: Union[Path, str]) -> None:
+    if not os.path.isabs(path):
+        path = Path.cwd() / path
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
 
+async def async_writefile(file: Union[str, Path], data: Union[str, bytes]) -> None:
+    def inner() -> None:
+        with open(file, "w" if isinstance(data, str) else "wb") as fh:
+            fh.write(data)
 
-def not_installed_error(message: str) -> Exception:
-    return Exception(
-        f"""
-================================================================================
-{message}
-Please complete Playwright installation via running
+    loop = asyncio.get_running_loop()
+    await loop.run_in_executor(None, inner)
 
-    "python -m playwright install"
 
-================================================================================
-"""
+async def async_readfile(file: Union[str, Path]) -> bytes:
+    def inner() -> bytes:
+        with open(file, "rb") as fh:
+            return fh.read()
+
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(None, inner)
+
+
+T = TypeVar("T")
+
+
+def to_impl(obj: T) -> T:
+    if hasattr(obj, "_impl_obj"):
+        return cast(Any, obj)._impl_obj
+    return obj
+
+
+def object_to_array(obj: Optional[Dict]) -> Optional[List[NameValue]]:
+    if not obj:
+        return None
+    result = []
+    for key, value in obj.items():
+        result.append(NameValue(name=key, value=str(value)))
+    return result
+
+
+def is_file_payload(value: Optional[Any]) -> bool:
+    return (
+        isinstance(value, dict)
+        and "name" in value
+        and "mimeType" in value
+        and "buffer" in value
     )
 
 
-to_snake_case_regex = re.compile("((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))")
+TEXTUAL_MIME_TYPE = re.compile(
+    r"^(text\/.*?|application\/(json|(x-)?javascript|xml.*?|ecmascript|graphql|x-www-form-urlencoded)|image\/svg(\+xml)?|application\/.*?(\+json|\+xml))(;\s*charset=.*)?$"
+)
 
 
-def to_snake_case(name: str) -> str:
-    return to_snake_case_regex.sub(r"_\1", name).lower()
+def is_textual_mime_type(mime_type: str) -> bool:
+    return bool(TEXTUAL_MIME_TYPE.match(mime_type))
+
+
+def to_milliseconds(
+    value: Union[float, datetime.timedelta, None],
+) -> Optional[float]:
+    if value is None:
+        return None
+    if isinstance(value, datetime.timedelta):
+        return value / datetime.timedelta(milliseconds=1)
+    return value
diff --git a/playwright/_impl/_impl_to_api_mapping.py b/playwright/_impl/_impl_to_api_mapping.py
index 5bf1d341d..8b3cbd756 100644
--- a/playwright/_impl/_impl_to_api_mapping.py
+++ b/playwright/_impl/_impl_to_api_mapping.py
@@ -13,41 +13,64 @@
 # limitations under the License.
 
 import inspect
-from typing import Any, Callable, Dict, List, Optional
-from weakref import WeakKeyDictionary
+from typing import Any, Callable, Dict, List, Optional, Sequence, Union
 
-from playwright._impl._api_types import ApiType, Error
+from playwright._impl._errors import Error
+from playwright._impl._map import Map
+
+API_ATTR = "_pw_api_instance_"
+IMPL_ATTR = "_pw_impl_instance_"
 
 
 class ImplWrapper:
     def __init__(self, impl_obj: Any) -> None:
         self._impl_obj = impl_obj
 
+    def __repr__(self) -> str:
+        return self._impl_obj.__repr__()
+
 
 class ImplToApiMapping:
     def __init__(self) -> None:
         self._mapping: Dict[type, type] = {}
-        self._instances: WeakKeyDictionary[Any, Any] = WeakKeyDictionary()
 
     def register(self, impl_class: type, api_class: type) -> None:
         self._mapping[impl_class] = api_class
 
-    def from_maybe_impl(self, obj: Any) -> Any:
+    def from_maybe_impl(
+        self, obj: Any, visited: Optional[Map[Any, Union[List, Dict]]] = None
+    ) -> Any:
+        # Python does share default arguments between calls, so we need to
+        # create a new map if it is not provided.
+        if not visited:
+            visited = Map()
         if not obj:
             return obj
-        if isinstance(obj, ApiType):
-            return obj
         if isinstance(obj, dict):
-            return {name: self.from_maybe_impl(value) for name, value in obj.items()}
+            if obj in visited:
+                return visited[obj]
+            o: Dict = {}
+            visited[obj] = o
+            for name, value in obj.items():
+                o[name] = self.from_maybe_impl(value, visited)
+            return o
         if isinstance(obj, list):
-            return [self.from_maybe_impl(item) for item in obj]
-        if obj not in self._instances:
-            api_class = self._mapping.get(type(obj))
-            if not api_class:
-                return obj
-            api_instance = api_class(obj)
-            self._instances[obj] = api_instance
-        return self._instances[obj]
+            if obj in visited:
+                return visited[obj]
+            a: List = []
+            visited[obj] = a
+            for item in obj:
+                a.append(self.from_maybe_impl(item, visited))
+            return a
+        api_class = self._mapping.get(type(obj))
+        if api_class:
+            api_instance = getattr(obj, API_ATTR, None)
+            if not api_instance:
+                api_instance = api_class(obj)
+                setattr(obj, API_ATTR, api_instance)
+            return api_instance
+        else:
+            return obj
 
     def from_impl(self, obj: Any) -> Any:
         assert obj
@@ -58,35 +81,78 @@ def from_impl(self, obj: Any) -> Any:
     def from_impl_nullable(self, obj: Any = None) -> Optional[Any]:
         return self.from_impl(obj) if obj else None
 
-    def from_impl_list(self, items: List[Any]) -> List[Any]:
+    def from_impl_list(self, items: Sequence[Any]) -> List[Any]:
         return list(map(lambda a: self.from_impl(a), items))
 
     def from_impl_dict(self, map: Dict[str, Any]) -> Dict[str, Any]:
         return {name: self.from_impl(value) for name, value in map.items()}
 
-    def to_impl(self, obj: Any) -> Any:
+    def to_impl(
+        self, obj: Any, visited: Optional[Map[Any, Union[List, Dict]]] = None
+    ) -> Any:
+        if visited is None:
+            visited = Map()
         try:
             if not obj:
                 return obj
             if isinstance(obj, dict):
-                return {name: self.to_impl(value) for name, value in obj.items()}
+                if obj in visited:
+                    return visited[obj]
+                o: Dict = {}
+                visited[obj] = o
+                for name, value in obj.items():
+                    o[name] = self.to_impl(value, visited)
+                return o
             if isinstance(obj, list):
-                return [self.to_impl(item) for item in obj]
+                if obj in visited:
+                    return visited[obj]
+                a: List = []
+                visited[obj] = a
+                for item in obj:
+                    a.append(self.to_impl(item, visited))
+                return a
             if isinstance(obj, ImplWrapper):
                 return obj._impl_obj
             return obj
         except RecursionError:
             raise Error("Maximum argument depth exceeded")
 
-    def wrap_handler(self, handler: Callable[..., None]) -> Callable[..., None]:
-        if handler in self._instances:
-            return self._instances[handler]
-
-        def wrapper(*args: Any) -> Any:
-            arg_count = len(inspect.signature(handler).parameters)
+    def wrap_handler(self, handler: Callable[..., Any]) -> Callable[..., None]:
+        def wrapper_func(*args: Any) -> Any:
+            parameters = inspect.signature(handler).parameters
+            has_varargs = any(
+                parameter.kind == inspect.Parameter.VAR_POSITIONAL
+                for parameter in parameters.values()
+            )
+            arg_count = (
+                len(args)
+                if has_varargs
+                else sum(
+                    parameter.kind
+                    in (
+                        inspect.Parameter.POSITIONAL_ONLY,
+                        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                    )
+                    for parameter in parameters.values()
+                )
+            )
             return handler(
                 *list(map(lambda a: self.from_maybe_impl(a), args))[:arg_count]
             )
 
-        self._instances[handler] = wrapper
+        if inspect.ismethod(handler):
+            wrapper = getattr(handler.__self__, IMPL_ATTR + handler.__name__, None)
+            if not wrapper:
+                wrapper = wrapper_func
+                setattr(
+                    handler.__self__,
+                    IMPL_ATTR + handler.__name__,
+                    wrapper,
+                )
+            return wrapper
+
+        wrapper = getattr(handler, IMPL_ATTR, None)
+        if not wrapper:
+            wrapper = wrapper_func
+            setattr(handler, IMPL_ATTR, wrapper)
         return wrapper
diff --git a/playwright/_impl/_input.py b/playwright/_impl/_input.py
index 4350617fa..8a39242ee 100644
--- a/playwright/_impl/_input.py
+++ b/playwright/_impl/_input.py
@@ -23,19 +23,19 @@ def __init__(self, channel: Channel) -> None:
         self._dispatcher_fiber = channel._connection._dispatcher_fiber
 
     async def down(self, key: str) -> None:
-        await self._channel.send("keyboardDown", locals_to_params(locals()))
+        await self._channel.send("keyboardDown", None, locals_to_params(locals()))
 
     async def up(self, key: str) -> None:
-        await self._channel.send("keyboardUp", locals_to_params(locals()))
+        await self._channel.send("keyboardUp", None, locals_to_params(locals()))
 
-    async def insertText(self, text: str) -> None:
-        await self._channel.send("keyboardInsertText", locals_to_params(locals()))
+    async def insert_text(self, text: str) -> None:
+        await self._channel.send("keyboardInsertText", None, locals_to_params(locals()))
 
-    async def type(self, text: str, delay: int = None) -> None:
-        await self._channel.send("keyboardType", locals_to_params(locals()))
+    async def type(self, text: str, delay: float = None) -> None:
+        await self._channel.send("keyboardType", None, locals_to_params(locals()))
 
-    async def press(self, key: str, delay: int = None) -> None:
-        await self._channel.send("keyboardPress", locals_to_params(locals()))
+    async def press(self, key: str, delay: float = None) -> None:
+        await self._channel.send("keyboardPress", None, locals_to_params(locals()))
 
 
 class Mouse:
@@ -45,40 +45,60 @@ def __init__(self, channel: Channel) -> None:
         self._dispatcher_fiber = channel._connection._dispatcher_fiber
 
     async def move(self, x: float, y: float, steps: int = None) -> None:
-        await self._channel.send("mouseMove", locals_to_params(locals()))
+        await self._channel.send("mouseMove", None, locals_to_params(locals()))
 
     async def down(
         self,
         button: MouseButton = None,
         clickCount: int = None,
     ) -> None:
-        await self._channel.send("mouseDown", locals_to_params(locals()))
+        await self._channel.send("mouseDown", None, locals_to_params(locals()))
 
     async def up(
         self,
         button: MouseButton = None,
         clickCount: int = None,
     ) -> None:
-        await self._channel.send("mouseUp", locals_to_params(locals()))
+        await self._channel.send("mouseUp", None, locals_to_params(locals()))
+
+    async def _click(
+        self,
+        x: float,
+        y: float,
+        delay: float = None,
+        button: MouseButton = None,
+        clickCount: int = None,
+        title: str = None,
+    ) -> None:
+        await self._channel.send(
+            "mouseClick", None, locals_to_params(locals()), title=title
+        )
 
     async def click(
         self,
         x: float,
         y: float,
-        delay: int = None,
+        delay: float = None,
         button: MouseButton = None,
         clickCount: int = None,
     ) -> None:
-        await self._channel.send("mouseClick", locals_to_params(locals()))
+        params = locals()
+        del params["self"]
+        await self._click(**params)
 
     async def dblclick(
         self,
         x: float,
         y: float,
-        delay: int = None,
+        delay: float = None,
         button: MouseButton = None,
     ) -> None:
-        await self.click(x, y, delay=delay, button=button, clickCount=2)
+        await self._click(
+            x, y, delay=delay, button=button, clickCount=2, title="Double click"
+        )
+
+    async def wheel(self, deltaX: float, deltaY: float) -> None:
+        await self._channel.send("mouseWheel", None, locals_to_params(locals()))
 
 
 class Touchscreen:
@@ -88,4 +108,4 @@ def __init__(self, channel: Channel) -> None:
         self._dispatcher_fiber = channel._connection._dispatcher_fiber
 
     async def tap(self, x: float, y: float) -> None:
-        await self._channel.send("touchscreenTap", locals_to_params(locals()))
+        await self._channel.send("touchscreenTap", None, locals_to_params(locals()))
diff --git a/playwright/_impl/_js_handle.py b/playwright/_impl/_js_handle.py
index dacf778b5..84ef40d18 100644
--- a/playwright/_impl/_js_handle.py
+++ b/playwright/_impl/_js_handle.py
@@ -12,13 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import base64
+import collections.abc
+import datetime
 import math
-from datetime import datetime
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+import struct
+import traceback
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from urllib.parse import ParseResult, urlparse, urlunparse
 
-from playwright._impl._api_types import Error
-from playwright._impl._connection import ChannelOwner, from_channel
-from playwright._impl._helper import is_function_body
+from playwright._impl._connection import Channel, ChannelOwner, from_channel
+from playwright._impl._errors import Error, is_target_closed_error
+from playwright._impl._map import Map
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._element_handle import ElementHandle
@@ -27,6 +33,21 @@
 Serializable = Any
 
 
+class VisitorInfo:
+    visited: Map[Any, int]
+    last_id: int
+
+    def __init__(self) -> None:
+        self.visited = Map()
+        self.last_id = 0
+
+    def visit(self, obj: Any) -> int:
+        assert obj not in self.visited
+        self.last_id += 1
+        self.visited[obj] = self.last_id
+        return self.last_id
+
+
 class JSHandle(ChannelOwner):
     def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
@@ -37,74 +58,88 @@ def __init__(
             "previewUpdated", lambda params: self._on_preview_updated(params["preview"])
         )
 
+    def __repr__(self) -> str:
+        return f"<JSHandle preview={self._preview}>"
+
     def __str__(self) -> str:
         return self._preview
 
     def _on_preview_updated(self, preview: str) -> None:
         self._preview = preview
 
-    async def evaluate(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
-    ) -> Any:
-        if not is_function_body(expression):
-            force_expr = True
+    async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
         return parse_result(
             await self._channel.send(
                 "evaluateExpression",
+                None,
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
-    async def evaluateHandle(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
+    async def evaluate_handle(
+        self, expression: str, arg: Serializable = None
     ) -> "JSHandle":
-        if not is_function_body(expression):
-            force_expr = True
         return from_channel(
             await self._channel.send(
                 "evaluateExpressionHandle",
+                None,
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
-    async def getProperty(self, propertyName: str) -> "JSHandle":
+    async def get_property(self, propertyName: str) -> "JSHandle":
         return from_channel(
-            await self._channel.send("getProperty", dict(name=propertyName))
+            await self._channel.send("getProperty", None, dict(name=propertyName))
         )
 
-    async def getProperties(self) -> Dict[str, "JSHandle"]:
+    async def get_properties(self) -> Dict[str, "JSHandle"]:
         return {
             prop["name"]: from_channel(prop["value"])
-            for prop in await self._channel.send("getPropertyList")
+            for prop in await self._channel.send(
+                "getPropertyList",
+                None,
+            )
         }
 
-    def asElement(self) -> Optional["ElementHandle"]:
+    def as_element(self) -> Optional["ElementHandle"]:
         return None
 
     async def dispose(self) -> None:
-        await self._channel.send("dispose")
+        try:
+            await self._channel.send(
+                "dispose",
+                None,
+            )
+        except Exception as e:
+            if not is_target_closed_error(e):
+                raise e
 
-    async def jsonValue(self) -> Any:
-        return parse_result(await self._channel.send("jsonValue"))
+    async def json_value(self) -> Any:
+        return parse_result(
+            await self._channel.send(
+                "jsonValue",
+                None,
+            )
+        )
 
 
-def serialize_value(value: Any, handles: List[JSHandle], depth: int) -> Any:
+def serialize_value(
+    value: Any, handles: List[Channel], visitor_info: Optional[VisitorInfo] = None
+) -> Any:
+    if visitor_info is None:
+        visitor_info = VisitorInfo()
     if isinstance(value, JSHandle):
         h = len(handles)
         handles.append(value._channel)
         return dict(h=h)
-    if depth > 100:
-        raise Error("Maximum argument depth exceeded")
     if value is None:
-        return dict(v="undefined")
+        return dict(v="null")
     if isinstance(value, float):
         if value == float("inf"):
             return dict(v="Infinity")
@@ -114,39 +149,76 @@ def serialize_value(value: Any, handles: List[JSHandle], depth: int) -> Any:
             return dict(v="-0")
         if math.isnan(value):
             return dict(v="NaN")
-    if isinstance(value, datetime):
-        return dict(d=value.isoformat() + "Z")
+    if isinstance(value, datetime.datetime):
+        # Node.js Date objects are always in UTC.
+        return {
+            "d": datetime.datetime.strftime(
+                value.astimezone(datetime.timezone.utc), "%Y-%m-%dT%H:%M:%S.%fZ"
+            )
+        }
+    if isinstance(value, Exception):
+        return {
+            "e": {
+                "m": str(value),
+                "n": (
+                    (value.name or "")
+                    if isinstance(value, Error)
+                    else value.__class__.__name__
+                ),
+                "s": (
+                    (value.stack or "")
+                    if isinstance(value, Error)
+                    else "".join(
+                        traceback.format_exception(type(value), value=value, tb=None)
+                    )
+                ),
+            }
+        }
     if isinstance(value, bool):
         return {"b": value}
     if isinstance(value, (int, float)):
         return {"n": value}
     if isinstance(value, str):
         return {"s": value}
+    if isinstance(value, ParseResult):
+        return {"u": urlunparse(value)}
+
+    if value in visitor_info.visited:
+        return dict(ref=visitor_info.visited[value])
 
-    if isinstance(value, list):
-        result = list(map(lambda a: serialize_value(a, handles, depth + 1), value))
-        return dict(a=result)
+    if isinstance(value, collections.abc.Sequence) and not isinstance(value, str):
+        id = visitor_info.visit(value)
+        a = []
+        for e in value:
+            a.append(serialize_value(e, handles, visitor_info))
+        return dict(a=a, id=id)
 
     if isinstance(value, dict):
-        result = []  # type: ignore
+        id = visitor_info.visit(value)
+        o = []
         for name in value:
-            result.append(
-                {"k": name, "v": serialize_value(value[name], handles, depth + 1)}
+            o.append(
+                {"k": name, "v": serialize_value(value[name], handles, visitor_info)}
             )
-        return dict(o=result)
+        return dict(o=o, id=id)
     return dict(v="undefined")
 
 
 def serialize_argument(arg: Serializable = None) -> Any:
-    handles: List[JSHandle] = []
-    value = serialize_value(arg, handles, 0)
+    handles: List[Channel] = []
+    value = serialize_value(arg, handles)
     return dict(value=value, handles=handles)
 
 
-def parse_value(value: Any) -> Any:
+def parse_value(value: Any, refs: Optional[Dict[int, Any]] = None) -> Any:
+    if refs is None:
+        refs = {}
     if value is None:
         return None
     if isinstance(value, dict):
+        if "ref" in value:
+            return refs[value["ref"]]
+
         if "v" in value:
             v = value["v"]
             if v == "Infinity":
@@ -163,15 +235,37 @@ def parse_value(value: Any) -> Any:
                 return None
             return v
 
+        if "u" in value:
+            return urlparse(value["u"])
+
+        if "bi" in value:
+            return int(value["bi"])
+
+        if "e" in value:
+            error = Error(value["e"]["m"])
+            error._name = value["e"]["n"]
+            error._stack = value["e"]["s"]
+            return error
+
         if "a" in value:
-            return list(map(lambda e: parse_value(e), value["a"]))
+            a: List = []
+            refs[value["id"]] = a
+            for e in value["a"]:
+                a.append(parse_value(e, refs))
+            return a
 
         if "d" in value:
-            return datetime.fromisoformat(value["d"][:-1])
+            # Node.js Date objects are always in UTC.
+            return datetime.datetime.strptime(
+                value["d"], "%Y-%m-%dT%H:%M:%S.%fZ"
+            ).replace(tzinfo=datetime.timezone.utc)
 
         if "o" in value:
-            o = value["o"]
-            return {e["k"]: parse_value(e["v"]) for e in o}
+            o: Dict = {}
+            refs[value["id"]] = o
+            for e in value["o"]:
+                o[e["k"]] = parse_value(e["v"], refs)
+            return o
 
         if "n" in value:
             return value["n"]
@@ -181,8 +275,62 @@ def parse_value(value: Any) -> Any:
 
         if "b" in value:
             return value["b"]
+
+        if "ta" in value:
+            encoded_bytes = value["ta"]["b"]
+            decoded_bytes = base64.b64decode(encoded_bytes)
+            array_type = value["ta"]["k"]
+            if array_type == "i8":
+                word_size = 1
+                fmt = "b"
+            elif array_type == "ui8" or array_type == "ui8c":
+                word_size = 1
+                fmt = "B"
+            elif array_type == "i16":
+                word_size = 2
+                fmt = "h"
+            elif array_type == "ui16":
+                word_size = 2
+                fmt = "H"
+            elif array_type == "i32":
+                word_size = 4
+                fmt = "i"
+            elif array_type == "ui32":
+                word_size = 4
+                fmt = "I"
+            elif array_type == "f32":
+                word_size = 4
+                fmt = "f"
+            elif array_type == "f64":
+                word_size = 8
+                fmt = "d"
+            elif array_type == "bi64":
+                word_size = 8
+                fmt = "q"
+            elif array_type == "bui64":
+                word_size = 8
+                fmt = "Q"
+            else:
+                raise ValueError(f"Unsupported array type: {array_type}")
+
+            byte_len = len(decoded_bytes)
+            if byte_len % word_size != 0:
+                raise ValueError(
+                    f"Decoded bytes length {byte_len} is not a multiple of word size {word_size}"
+                )
+
+            if byte_len == 0:
+                return []
+            array_len = byte_len // word_size
+            # "<" denotes little-endian
+            format_string = f"<{array_len}{fmt}"
+            return list(struct.unpack(format_string, decoded_bytes))
     return value
 
 
 def parse_result(result: Any) -> Any:
     return parse_value(result)
+
+
+def add_source_url_to_script(source: str, path: Union[str, Path]) -> str:
+    return source + "\n//# sourceURL=" + str(path).replace("\n", "")
diff --git a/playwright/_impl/_json_pipe.py b/playwright/_impl/_json_pipe.py
new file mode 100644
index 000000000..41973b8c7
--- /dev/null
+++ b/playwright/_impl/_json_pipe.py
@@ -0,0 +1,77 @@
+# 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 asyncio
+from typing import Dict, Optional, cast
+
+from pyee.asyncio import AsyncIOEventEmitter
+
+from playwright._impl._connection import Channel
+from playwright._impl._errors import TargetClosedError
+from playwright._impl._helper import Error, ParsedMessagePayload
+from playwright._impl._transport import Transport
+
+
+class JsonPipeTransport(AsyncIOEventEmitter, Transport):
+    def __init__(
+        self,
+        loop: asyncio.AbstractEventLoop,
+        pipe_channel: Channel,
+    ) -> None:
+        super().__init__(loop)
+        Transport.__init__(self, loop)
+        self._stop_requested = False
+        self._pipe_channel = pipe_channel
+
+    def request_stop(self) -> None:
+        self._stop_requested = True
+        self._pipe_channel.send_no_reply("close", None, {})
+
+    def dispose(self) -> None:
+        self.on_error_future.cancel()
+        self._stopped_future.cancel()
+
+    async def wait_until_stopped(self) -> None:
+        await self._stopped_future
+
+    async def connect(self) -> None:
+        self._stopped_future: asyncio.Future = asyncio.Future()
+
+        def handle_message(message: Dict) -> None:
+            if self._stop_requested:
+                return
+            self.on_message(cast(ParsedMessagePayload, message))
+
+        def handle_closed(reason: Optional[str]) -> None:
+            self.emit("close", reason)
+            if reason:
+                self.on_error_future.set_exception(TargetClosedError(reason))
+            self._stopped_future.set_result(None)
+
+        self._pipe_channel.on(
+            "message",
+            lambda params: handle_message(params["message"]),
+        )
+        self._pipe_channel.on(
+            "closed",
+            lambda params: handle_closed(params.get("reason")),
+        )
+
+    async def run(self) -> None:
+        await self._stopped_future
+
+    def send(self, message: Dict) -> None:
+        if self._stop_requested:
+            raise Error("Playwright connection closed")
+        self._pipe_channel.send_no_reply("send", None, {"message": message})
diff --git a/playwright/_impl/_local_utils.py b/playwright/_impl/_local_utils.py
new file mode 100644
index 000000000..cd8fd8343
--- /dev/null
+++ b/playwright/_impl/_local_utils.py
@@ -0,0 +1,95 @@
+# 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 base64
+from typing import Dict, List, Optional, cast
+
+from playwright._impl._api_structures import HeadersArray
+from playwright._impl._connection import ChannelOwner, StackFrame
+from playwright._impl._helper import HarLookupResult, locals_to_params
+
+
+class LocalUtils(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self.devices = {
+            device["name"]: parse_device_descriptor(device["descriptor"])
+            for device in initializer["deviceDescriptors"]
+        }
+
+    async def zip(self, params: Dict) -> None:
+        await self._channel.send("zip", None, params)
+
+    async def har_open(self, file: str) -> None:
+        params = locals_to_params(locals())
+        await self._channel.send("harOpen", None, params)
+
+    async def har_lookup(
+        self,
+        harId: str,
+        url: str,
+        method: str,
+        headers: HeadersArray,
+        isNavigationRequest: bool,
+        postData: Optional[bytes] = None,
+    ) -> HarLookupResult:
+        params = locals_to_params(locals())
+        if "postData" in params:
+            params["postData"] = base64.b64encode(params["postData"]).decode()
+        return cast(
+            HarLookupResult,
+            await self._channel.send_return_as_dict("harLookup", None, params),
+        )
+
+    async def har_close(self, harId: str) -> None:
+        params = locals_to_params(locals())
+        await self._channel.send("harClose", None, params)
+
+    async def har_unzip(self, zipFile: str, harFile: str) -> None:
+        params = locals_to_params(locals())
+        await self._channel.send("harUnzip", None, params)
+
+    async def tracing_started(
+        self, tracesDir: Optional[str], traceName: str, live: bool = False
+    ) -> str:
+        params = locals_to_params(locals())
+        return await self._channel.send("tracingStarted", None, params)
+
+    async def trace_discarded(self, stacks_id: str) -> None:
+        return await self._channel.send("traceDiscarded", None, {"stacksId": stacks_id})
+
+    def add_stack_to_tracing_no_reply(self, id: int, frames: List[StackFrame]) -> None:
+        self._channel.send_no_reply(
+            "addStackToTracingNoReply",
+            None,
+            {
+                "callData": {
+                    "stack": frames,
+                    "id": id,
+                }
+            },
+        )
+
+
+def parse_device_descriptor(dict: Dict) -> Dict:
+    return {
+        "user_agent": dict["userAgent"],
+        "viewport": dict["viewport"],
+        "device_scale_factor": dict["deviceScaleFactor"],
+        "is_mobile": dict["isMobile"],
+        "has_touch": dict["hasTouch"],
+        "default_browser_type": dict["defaultBrowserType"],
+    }
diff --git a/playwright/_impl/_locator.py b/playwright/_impl/_locator.py
new file mode 100644
index 000000000..c76b248ce
--- /dev/null
+++ b/playwright/_impl/_locator.py
@@ -0,0 +1,996 @@
+# 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 json
+import pathlib
+import re
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Pattern,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+)
+
+from playwright._impl._api_structures import (
+    AriaRole,
+    DropPayload,
+    FilePayload,
+    FloatRect,
+    FrameExpectOptions,
+    FrameExpectResult,
+    Position,
+)
+from playwright._impl._element_handle import ElementHandle
+from playwright._impl._helper import (
+    Error,
+    KeyboardModifier,
+    MouseButton,
+    locals_to_params,
+    monotonic_time,
+    to_impl,
+)
+from playwright._impl._js_handle import Serializable
+from playwright._impl._str_utils import (
+    escape_for_attribute_selector,
+    escape_for_text_selector,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._frame import Frame
+    from playwright._impl._js_handle import JSHandle
+    from playwright._impl._page import Page
+
+T = TypeVar("T")
+
+
+class Locator:
+    def __init__(
+        self,
+        frame: "Frame",
+        selector: str,
+        has_text: Union[str, Pattern[str]] = None,
+        has_not_text: Union[str, Pattern[str]] = None,
+        has: "Locator" = None,
+        has_not: "Locator" = None,
+        visible: bool = None,
+    ) -> None:
+        self._frame = frame
+        self._selector = selector
+        self._loop = frame._loop
+        self._dispatcher_fiber = frame._connection._dispatcher_fiber
+
+        if has_text:
+            self._selector += f" >> internal:has-text={escape_for_text_selector(has_text, exact=False)}"
+
+        if has:
+            if has._frame != frame:
+                raise Error('Inner "has" locator must belong to the same frame.')
+            self._selector += " >> internal:has=" + json.dumps(
+                has._selector, ensure_ascii=False
+            )
+
+        if has_not_text:
+            self._selector += f" >> internal:has-not-text={escape_for_text_selector(has_not_text, exact=False)}"
+
+        if has_not:
+            locator = has_not
+            if locator._frame != frame:
+                raise Error('Inner "has_not" locator must belong to the same frame.')
+            self._selector += " >> internal:has-not=" + json.dumps(locator._selector)
+
+        if visible is not None:
+            self._selector += f" >> visible={bool_to_js_bool(visible)}"
+
+    def __repr__(self) -> str:
+        return f"<Locator frame={self._frame!r} selector={self._selector!r}>"
+
+    async def _with_element(
+        self,
+        task: Callable[[ElementHandle, float], Awaitable[T]],
+        timeout: float = None,
+    ) -> T:
+        timeout = self._frame._timeout(timeout)
+        deadline = (monotonic_time() + timeout) if timeout else 0
+        handle = await self.element_handle(timeout=timeout)
+        if not handle:
+            raise Error(f"Could not resolve {self._selector} to DOM Element")
+        try:
+            return await task(
+                handle,
+                (deadline - monotonic_time()) if deadline else 0,
+            )
+        finally:
+            await handle.dispose()
+
+    def _equals(self, locator: "Locator") -> bool:
+        return self._frame == locator._frame and self._selector == locator._selector
+
+    @property
+    def page(self) -> "Page":
+        return self._frame.page
+
+    async def bounding_box(self, timeout: float = None) -> Optional[FloatRect]:
+        return await self._with_element(
+            lambda h, _: h.bounding_box(),
+            timeout,
+        )
+
+    async def check(
+        self,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        trial: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        return await self._frame.check(self._selector, strict=True, **params)
+
+    async def click(
+        self,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
+        button: MouseButton = None,
+        clickCount: int = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        trial: bool = None,
+        steps: int = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        return await self._frame._click(self._selector, strict=True, **params)
+
+    async def dblclick(
+        self,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
+        button: MouseButton = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        trial: bool = None,
+        steps: int = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        return await self._frame.dblclick(self._selector, strict=True, **params)
+
+    async def dispatch_event(
+        self,
+        type: str,
+        eventInit: Dict = None,
+        timeout: float = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        return await self._frame.dispatch_event(self._selector, strict=True, **params)
+
+    async def evaluate(
+        self, expression: str, arg: Serializable = None, timeout: float = None
+    ) -> Any:
+        return await self._with_element(
+            lambda h, _: h.evaluate(expression, arg),
+            timeout,
+        )
+
+    async def evaluate_all(self, expression: str, arg: Serializable = None) -> Any:
+        params = locals_to_params(locals())
+        return await self._frame.eval_on_selector_all(self._selector, **params)
+
+    async def evaluate_handle(
+        self, expression: str, arg: Serializable = None, timeout: float = None
+    ) -> "JSHandle":
+        return await self._with_element(
+            lambda h, _: h.evaluate_handle(expression, arg), timeout
+        )
+
+    async def fill(
+        self,
+        value: str,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        force: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        return await self._frame.fill(self._selector, strict=True, **params)
+
+    async def clear(
+        self,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        force: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        await self._frame._fill(self._selector, value="", title="Clear", **params)
+
+    def locator(
+        self,
+        selectorOrLocator: Union[str, "Locator"],
+        hasText: Union[str, Pattern[str]] = None,
+        hasNotText: Union[str, Pattern[str]] = None,
+        has: "Locator" = None,
+        hasNot: "Locator" = None,
+    ) -> "Locator":
+        if isinstance(selectorOrLocator, str):
+            return Locator(
+                self._frame,
+                f"{self._selector} >> {selectorOrLocator}",
+                has_text=hasText,
+                has_not_text=hasNotText,
+                has_not=hasNot,
+                has=has,
+            )
+        selectorOrLocator = to_impl(selectorOrLocator)
+        if selectorOrLocator._frame != self._frame:
+            raise Error("Locators must belong to the same frame.")
+        return Locator(
+            self._frame,
+            f"{self._selector} >> internal:chain={json.dumps(selectorOrLocator._selector)}",
+            has_text=hasText,
+            has_not_text=hasNotText,
+            has_not=hasNot,
+            has=has,
+        )
+
+    def get_by_alt_text(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_alt_text_selector(text, exact=exact))
+
+    def get_by_label(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_label_selector(text, exact=exact))
+
+    def get_by_placeholder(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_placeholder_selector(text, exact=exact))
+
+    def get_by_role(
+        self,
+        role: AriaRole,
+        checked: bool = None,
+        disabled: bool = None,
+        expanded: bool = None,
+        includeHidden: bool = None,
+        level: int = None,
+        name: Union[str, Pattern[str]] = None,
+        pressed: bool = None,
+        selected: bool = None,
+        exact: bool = None,
+        description: Union[str, Pattern[str]] = None,
+    ) -> "Locator":
+        return self.locator(
+            get_by_role_selector(
+                role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=includeHidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
+
+    def get_by_test_id(self, testId: Union[str, Pattern[str]]) -> "Locator":
+        return self.locator(get_by_test_id_selector(test_id_attribute_name(), testId))
+
+    def get_by_text(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_text_selector(text, exact=exact))
+
+    def get_by_title(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_title_selector(text, exact=exact))
+
+    def frame_locator(self, selector: str) -> "FrameLocator":
+        return FrameLocator(self._frame, self._selector + " >> " + selector)
+
+    async def element_handle(
+        self,
+        timeout: float = None,
+    ) -> ElementHandle:
+        params = locals_to_params(locals())
+        handle = await self._frame.wait_for_selector(
+            self._selector, strict=True, state="attached", **params
+        )
+        assert handle
+        return handle
+
+    async def element_handles(self) -> List[ElementHandle]:
+        return await self._frame.query_selector_all(self._selector)
+
+    @property
+    def first(self) -> "Locator":
+        return Locator(self._frame, f"{self._selector} >> nth=0")
+
+    @property
+    def last(self) -> "Locator":
+        return Locator(self._frame, f"{self._selector} >> nth=-1")
+
+    def nth(self, index: int) -> "Locator":
+        return Locator(self._frame, f"{self._selector} >> nth={index}")
+
+    @property
+    def content_frame(self) -> "FrameLocator":
+        return FrameLocator(self._frame, self._selector)
+
+    def describe(self, description: str) -> "Locator":
+        return Locator(
+            self._frame,
+            f"{self._selector} >> internal:describe={json.dumps(description)}",
+        )
+
+    @property
+    def description(self) -> Optional[str]:
+        try:
+            match = re.search(
+                r' >> internal:describe=("(?:[^"\\]|\\.)*")$', self._selector
+            )
+            if match:
+                description = json.loads(match.group(1))
+                if isinstance(description, str):
+                    return description
+        except (json.JSONDecodeError, ValueError):
+            pass
+        return None
+
+    def filter(
+        self,
+        hasText: Union[str, Pattern[str]] = None,
+        hasNotText: Union[str, Pattern[str]] = None,
+        has: "Locator" = None,
+        hasNot: "Locator" = None,
+        visible: bool = None,
+    ) -> "Locator":
+        return Locator(
+            self._frame,
+            self._selector,
+            has_text=hasText,
+            has_not_text=hasNotText,
+            has=has,
+            has_not=hasNot,
+            visible=visible,
+        )
+
+    def or_(self, locator: "Locator") -> "Locator":
+        if locator._frame != self._frame:
+            raise Error("Locators must belong to the same frame.")
+        return Locator(
+            self._frame,
+            self._selector + " >> internal:or=" + json.dumps(locator._selector),
+        )
+
+    def and_(self, locator: "Locator") -> "Locator":
+        if locator._frame != self._frame:
+            raise Error("Locators must belong to the same frame.")
+        return Locator(
+            self._frame,
+            self._selector + " >> internal:and=" + json.dumps(locator._selector),
+        )
+
+    async def focus(self, timeout: float = None) -> None:
+        params = locals_to_params(locals())
+        return await self._frame.focus(self._selector, strict=True, **params)
+
+    async def blur(self, timeout: float = None) -> None:
+        await self._frame._channel.send(
+            "blur",
+            self._frame._timeout,
+            {
+                "selector": self._selector,
+                "strict": True,
+                **locals_to_params(locals()),
+            },
+        )
+
+    async def all(
+        self,
+    ) -> List["Locator"]:
+        result = []
+        for index in range(await self.count()):
+            result.append(self.nth(index))
+        return result
+
+    async def count(
+        self,
+    ) -> int:
+        return await self._frame._query_count(self._selector)
+
+    async def drag_to(
+        self,
+        target: "Locator",
+        force: bool = None,
+        noWaitAfter: bool = None,
+        timeout: float = None,
+        trial: bool = None,
+        sourcePosition: Position = None,
+        targetPosition: Position = None,
+        steps: int = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        del params["target"]
+        return await self._frame.drag_and_drop(
+            self._selector, target._selector, strict=True, **params
+        )
+
+    async def drop(
+        self,
+        payload: DropPayload,
+        position: Position = None,
+        timeout: float = None,
+    ) -> None:
+        await self._frame._drop(
+            self._selector,
+            payload,
+            strict=True,
+            position=position,
+            timeout=timeout,
+        )
+
+    async def get_attribute(self, name: str, timeout: float = None) -> Optional[str]:
+        params = locals_to_params(locals())
+        return await self._frame.get_attribute(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def hover(
+        self,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        force: bool = None,
+        trial: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        return await self._frame.hover(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def inner_html(self, timeout: float = None) -> str:
+        params = locals_to_params(locals())
+        return await self._frame.inner_html(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def inner_text(self, timeout: float = None) -> str:
+        params = locals_to_params(locals())
+        return await self._frame.inner_text(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def input_value(self, timeout: float = None) -> str:
+        params = locals_to_params(locals())
+        return await self._frame.input_value(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def is_checked(self, timeout: float = None) -> bool:
+        params = locals_to_params(locals())
+        return await self._frame.is_checked(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def is_disabled(self, timeout: float = None) -> bool:
+        params = locals_to_params(locals())
+        return await self._frame.is_disabled(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def is_editable(self, timeout: float = None) -> bool:
+        params = locals_to_params(locals())
+        return await self._frame.is_editable(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def is_enabled(self, timeout: float = None) -> bool:
+        params = locals_to_params(locals())
+        return await self._frame.is_enabled(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def is_hidden(self, timeout: float = None) -> bool:
+        # timeout is deprecated and does nothing
+        return await self._frame.is_hidden(
+            self._selector,
+            strict=True,
+        )
+
+    async def is_visible(self, timeout: float = None) -> bool:
+        # timeout is deprecated and does nothing
+        return await self._frame.is_visible(
+            self._selector,
+            strict=True,
+        )
+
+    async def press(
+        self,
+        key: str,
+        delay: float = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        return await self._frame.press(self._selector, strict=True, **params)
+
+    async def screenshot(
+        self,
+        timeout: float = None,
+        type: Literal["jpeg", "png"] = None,
+        path: Union[str, pathlib.Path] = None,
+        quality: int = None,
+        omitBackground: bool = None,
+        animations: Literal["allow", "disabled"] = None,
+        caret: Literal["hide", "initial"] = None,
+        scale: Literal["css", "device"] = None,
+        mask: Sequence["Locator"] = None,
+        maskColor: str = None,
+        style: str = None,
+    ) -> bytes:
+        params = locals_to_params(locals())
+        return await self._with_element(
+            lambda h, timeout: h.screenshot(
+                **{**params, "timeout": timeout},
+            ),
+        )
+
+    async def aria_snapshot(
+        self,
+        timeout: float = None,
+        depth: int = None,
+        mode: Literal["ai", "default"] = None,
+        boxes: bool = None,
+    ) -> str:
+        return await self._frame._channel.send(
+            "ariaSnapshot",
+            self._frame._timeout,
+            {
+                "selector": self._selector,
+                **locals_to_params(locals()),
+            },
+        )
+
+    async def normalize(self) -> "Locator":
+        result = await self._frame._channel.send(
+            "resolveSelector",
+            None,
+            {"selector": self._selector},
+        )
+        return Locator(self._frame, result)
+
+    async def scroll_into_view_if_needed(
+        self,
+        timeout: float = None,
+    ) -> None:
+        return await self._with_element(
+            lambda h, timeout: h.scroll_into_view_if_needed(timeout=timeout),
+            timeout,
+        )
+
+    async def select_option(
+        self,
+        value: Union[str, Sequence[str]] = None,
+        index: Union[int, Sequence[int]] = None,
+        label: Union[str, Sequence[str]] = None,
+        element: Union["ElementHandle", Sequence["ElementHandle"]] = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        force: bool = None,
+    ) -> List[str]:
+        params = locals_to_params(locals())
+        return await self._frame.select_option(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def select_text(self, force: bool = None, timeout: float = None) -> None:
+        params = locals_to_params(locals())
+        return await self._with_element(
+            lambda h, timeout: h.select_text(**{**params, "timeout": timeout}),
+            timeout,
+        )
+
+    async def set_input_files(
+        self,
+        files: Union[
+            str,
+            pathlib.Path,
+            FilePayload,
+            Sequence[Union[str, pathlib.Path]],
+            Sequence[FilePayload],
+        ],
+        timeout: float = None,
+        noWaitAfter: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        return await self._frame.set_input_files(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def tap(
+        self,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        trial: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        return await self._frame.tap(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def text_content(self, timeout: float = None) -> Optional[str]:
+        params = locals_to_params(locals())
+        return await self._frame.text_content(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def type(
+        self,
+        text: str,
+        delay: float = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        return await self._frame.type(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def press_sequentially(
+        self,
+        text: str,
+        delay: float = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+    ) -> None:
+        await self.type(text, delay=delay, timeout=timeout)
+
+    async def uncheck(
+        self,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        trial: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        return await self._frame.uncheck(
+            self._selector,
+            strict=True,
+            **params,
+        )
+
+    async def all_inner_texts(
+        self,
+    ) -> List[str]:
+        return await self._frame.eval_on_selector_all(
+            self._selector, "ee => ee.map(e => e.innerText)"
+        )
+
+    async def all_text_contents(
+        self,
+    ) -> List[str]:
+        return await self._frame.eval_on_selector_all(
+            self._selector, "ee => ee.map(e => e.textContent || '')"
+        )
+
+    async def wait_for(
+        self,
+        timeout: float = None,
+        state: Literal["attached", "detached", "hidden", "visible"] = None,
+    ) -> None:
+        await self._frame.wait_for_selector(
+            self._selector, strict=True, timeout=timeout, state=state
+        )
+
+    async def set_checked(
+        self,
+        checked: bool,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        trial: bool = None,
+    ) -> None:
+        if checked:
+            await self.check(
+                position=position,
+                timeout=timeout,
+                force=force,
+                trial=trial,
+            )
+        else:
+            await self.uncheck(
+                position=position,
+                timeout=timeout,
+                force=force,
+                trial=trial,
+            )
+
+    async def _expect(
+        self,
+        expression: str,
+        options: FrameExpectOptions,
+        title: str = None,
+    ) -> FrameExpectResult:
+        return await self._frame._expect(self._selector, expression, options, title)
+
+    async def highlight(self, style: str = None) -> None:
+        await self._frame._highlight(self._selector, style)
+
+    async def hide_highlight(self) -> None:
+        await self._frame._hide_highlight(self._selector)
+
+
+class FrameLocator:
+    def __init__(self, frame: "Frame", frame_selector: str) -> None:
+        self._frame = frame
+        self._loop = frame._loop
+        self._dispatcher_fiber = frame._connection._dispatcher_fiber
+        self._frame_selector = frame_selector
+
+    def locator(
+        self,
+        selectorOrLocator: Union["Locator", str],
+        hasText: Union[str, Pattern[str]] = None,
+        hasNotText: Union[str, Pattern[str]] = None,
+        has: Locator = None,
+        hasNot: Locator = None,
+    ) -> Locator:
+        if isinstance(selectorOrLocator, str):
+            return Locator(
+                self._frame,
+                f"{self._frame_selector} >> internal:control=enter-frame >> {selectorOrLocator}",
+                has_text=hasText,
+                has_not_text=hasNotText,
+                has=has,
+                has_not=hasNot,
+            )
+        selectorOrLocator = to_impl(selectorOrLocator)
+        if selectorOrLocator._frame != self._frame:
+            raise ValueError("Locators must belong to the same frame.")
+        return Locator(
+            self._frame,
+            f"{self._frame_selector} >> internal:control=enter-frame >> {selectorOrLocator._selector}",
+            has_text=hasText,
+            has_not_text=hasNotText,
+            has=has,
+            has_not=hasNot,
+        )
+
+    def get_by_alt_text(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_alt_text_selector(text, exact=exact))
+
+    def get_by_label(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_label_selector(text, exact=exact))
+
+    def get_by_placeholder(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_placeholder_selector(text, exact=exact))
+
+    def get_by_role(
+        self,
+        role: AriaRole,
+        checked: bool = None,
+        disabled: bool = None,
+        expanded: bool = None,
+        includeHidden: bool = None,
+        level: int = None,
+        name: Union[str, Pattern[str]] = None,
+        pressed: bool = None,
+        selected: bool = None,
+        exact: bool = None,
+        description: Union[str, Pattern[str]] = None,
+    ) -> "Locator":
+        return self.locator(
+            get_by_role_selector(
+                role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=includeHidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
+
+    def get_by_test_id(self, testId: Union[str, Pattern[str]]) -> "Locator":
+        return self.locator(get_by_test_id_selector(test_id_attribute_name(), testId))
+
+    def get_by_text(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_text_selector(text, exact=exact))
+
+    def get_by_title(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self.locator(get_by_title_selector(text, exact=exact))
+
+    def frame_locator(self, selector: str) -> "FrameLocator":
+        return FrameLocator(
+            self._frame,
+            f"{self._frame_selector} >> internal:control=enter-frame >> {selector}",
+        )
+
+    @property
+    def first(self) -> "FrameLocator":
+        return FrameLocator(self._frame, f"{self._frame_selector} >> nth=0")
+
+    @property
+    def last(self) -> "FrameLocator":
+        return FrameLocator(self._frame, f"{self._frame_selector} >> nth=-1")
+
+    @property
+    def owner(self) -> "Locator":
+        return Locator(self._frame, self._frame_selector)
+
+    def nth(self, index: int) -> "FrameLocator":
+        return FrameLocator(self._frame, f"{self._frame_selector} >> nth={index}")
+
+    def __repr__(self) -> str:
+        return f"<FrameLocator frame={self._frame!r} selector={self._frame_selector!r}>"
+
+
+_test_id_attribute_name: str = "data-testid"
+
+
+def test_id_attribute_name() -> str:
+    return _test_id_attribute_name
+
+
+def set_test_id_attribute_name(attribute_name: str) -> None:
+    global _test_id_attribute_name
+    _test_id_attribute_name = attribute_name
+
+
+def get_by_test_id_selector(
+    test_id_attribute_name: str, test_id: Union[str, Pattern[str]]
+) -> str:
+    return f"internal:testid=[{test_id_attribute_name}={escape_for_attribute_selector(test_id, True)}]"
+
+
+def get_by_attribute_text_selector(
+    attr_name: str, text: Union[str, Pattern[str]], exact: bool = None
+) -> str:
+    return f"internal:attr=[{attr_name}={escape_for_attribute_selector(text, exact=exact)}]"
+
+
+def get_by_label_selector(text: Union[str, Pattern[str]], exact: bool = None) -> str:
+    return "internal:label=" + escape_for_text_selector(text, exact=exact)
+
+
+def get_by_alt_text_selector(text: Union[str, Pattern[str]], exact: bool = None) -> str:
+    return get_by_attribute_text_selector("alt", text, exact=exact)
+
+
+def get_by_title_selector(text: Union[str, Pattern[str]], exact: bool = None) -> str:
+    return get_by_attribute_text_selector("title", text, exact=exact)
+
+
+def get_by_placeholder_selector(
+    text: Union[str, Pattern[str]], exact: bool = None
+) -> str:
+    return get_by_attribute_text_selector("placeholder", text, exact=exact)
+
+
+def get_by_text_selector(text: Union[str, Pattern[str]], exact: bool = None) -> str:
+    return "internal:text=" + escape_for_text_selector(text, exact=exact)
+
+
+def bool_to_js_bool(value: bool) -> str:
+    return "true" if value else "false"
+
+
+def get_by_role_selector(
+    role: AriaRole,
+    checked: bool = None,
+    disabled: bool = None,
+    expanded: bool = None,
+    includeHidden: bool = None,
+    level: int = None,
+    name: Union[str, Pattern[str]] = None,
+    pressed: bool = None,
+    selected: bool = None,
+    exact: bool = None,
+    description: Union[str, Pattern[str]] = None,
+) -> str:
+    props: List[Tuple[str, str]] = []
+    if checked is not None:
+        props.append(("checked", bool_to_js_bool(checked)))
+    if disabled is not None:
+        props.append(("disabled", bool_to_js_bool(disabled)))
+    if selected is not None:
+        props.append(("selected", bool_to_js_bool(selected)))
+    if expanded is not None:
+        props.append(("expanded", bool_to_js_bool(expanded)))
+    if includeHidden is not None:
+        props.append(("include-hidden", bool_to_js_bool(includeHidden)))
+    if level is not None:
+        props.append(("level", str(level)))
+    if name is not None:
+        props.append(
+            (
+                "name",
+                escape_for_attribute_selector(name, exact=exact),
+            )
+        )
+    if description is not None:
+        props.append(
+            (
+                "description",
+                escape_for_attribute_selector(description, exact=exact),
+            )
+        )
+    if pressed is not None:
+        props.append(("pressed", bool_to_js_bool(pressed)))
+    props_str = "".join([f"[{t[0]}={t[1]}]" for t in props])
+    return f"internal:role={role}{props_str}"
diff --git a/playwright/_impl/_map.py b/playwright/_impl/_map.py
new file mode 100644
index 000000000..95c05f445
--- /dev/null
+++ b/playwright/_impl/_map.py
@@ -0,0 +1,31 @@
+# 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.
+from typing import Dict, Generic, Tuple, TypeVar
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class Map(Generic[K, V]):
+    def __init__(self) -> None:
+        self._entries: Dict[int, Tuple[K, V]] = {}
+
+    def __contains__(self, item: K) -> bool:
+        return id(item) in self._entries
+
+    def __setitem__(self, idx: K, value: V) -> None:
+        self._entries[id(idx)] = (idx, value)
+
+    def __getitem__(self, obj: K) -> V:
+        return self._entries[id(obj)][1]
diff --git a/playwright/_impl/_network.py b/playwright/_impl/_network.py
index 2f68f918b..240fb6653 100644
--- a/playwright/_impl/_network.py
+++ b/playwright/_impl/_network.py
@@ -12,27 +12,118 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
 import base64
+import inspect
 import json
+import json as json_utils
 import mimetypes
+import re
+from collections import defaultdict
 from pathlib import Path
 from types import SimpleNamespace
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    List,
+    Optional,
+    TypedDict,
+    Union,
+    cast,
+)
 from urllib import parse
 
-from playwright._impl._api_structures import ResourceTiming
-from playwright._impl._api_types import Error
+from playwright._impl._api_structures import (
+    ClientCertificate,
+    Headers,
+    HeadersArray,
+    RemoteAddr,
+    RequestSizes,
+    ResourceTiming,
+    SecurityDetails,
+)
 from playwright._impl._connection import (
     ChannelOwner,
     from_channel,
     from_nullable_channel,
 )
+from playwright._impl._errors import Error
 from playwright._impl._event_context_manager import EventContextManagerImpl
-from playwright._impl._helper import ContinueParameters, Header, locals_to_params
-from playwright._impl._wait_helper import WaitHelper
+from playwright._impl._helper import (
+    URLMatch,
+    WebSocketRouteHandlerCallback,
+    async_readfile,
+    locals_to_params,
+    url_matches,
+)
+from playwright._impl._str_utils import escape_regex_flags
+from playwright._impl._waiter import Waiter
 
 if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._browser_context import BrowserContext
+    from playwright._impl._fetch import APIResponse
     from playwright._impl._frame import Frame
+    from playwright._impl._page import Page, Worker
+
+
+class FallbackOverrideParameters(TypedDict, total=False):
+    url: Optional[str]
+    method: Optional[str]
+    headers: Optional[Dict[str, str]]
+    postData: Optional[Union[str, bytes]]
+
+
+class SerializedFallbackOverrides:
+    def __init__(self) -> None:
+        self.url: Optional[str] = None
+        self.method: Optional[str] = None
+        self.headers: Optional[Dict[str, str]] = None
+        self.post_data_buffer: Optional[bytes] = None
+
+
+def serialize_headers(headers: Dict[str, str]) -> HeadersArray:
+    return [
+        {"name": name, "value": value}
+        for name, value in headers.items()
+        if value is not None
+    ]
+
+
+async def to_client_certificates_protocol(
+    clientCertificates: Optional[List[ClientCertificate]],
+) -> Optional[List[Dict[str, str]]]:
+    if not clientCertificates:
+        return None
+    out = []
+    for clientCertificate in clientCertificates:
+        out_record = {
+            "origin": clientCertificate["origin"],
+        }
+        if passphrase := clientCertificate.get("passphrase"):
+            out_record["passphrase"] = passphrase
+        if pfx := clientCertificate.get("pfx"):
+            out_record["pfx"] = base64.b64encode(pfx).decode()
+        if pfx_path := clientCertificate.get("pfxPath"):
+            out_record["pfx"] = base64.b64encode(
+                await async_readfile(pfx_path)
+            ).decode()
+        if cert := clientCertificate.get("cert"):
+            out_record["cert"] = base64.b64encode(cert).decode()
+        if cert_path := clientCertificate.get("certPath"):
+            out_record["cert"] = base64.b64encode(
+                await async_readfile(cert_path)
+            ).decode()
+        if key := clientCertificate.get("key"):
+            out_record["key"] = base64.b64encode(key).decode()
+        if key_path := clientCertificate.get("keyPath"):
+            out_record["key"] = base64.b64encode(
+                await async_readfile(key_path)
+            ).decode()
+        out.append(out_record)
+    return out
 
 
 class Request(ChannelOwner):
@@ -58,67 +149,131 @@ def __init__(
             "responseStart": -1,
             "responseEnd": -1,
         }
-        self._headers: Dict[str, str] = parse_headers(self._initializer["headers"])
+        self._provisional_headers = RawHeaders(self._initializer["headers"])
+        self._all_headers_future: Optional[asyncio.Future[RawHeaders]] = None
+        self._fallback_overrides: SerializedFallbackOverrides = (
+            SerializedFallbackOverrides()
+        )
+        self._response: Optional["Response"] = None
+
+    def __repr__(self) -> str:
+        return f"<Request url={self.url!r} method={self.method!r}>"
+
+    def _apply_fallback_overrides(self, overrides: FallbackOverrideParameters) -> None:
+        self._fallback_overrides.url = overrides.get(
+            "url", self._fallback_overrides.url
+        )
+        self._fallback_overrides.method = overrides.get(
+            "method", self._fallback_overrides.method
+        )
+        self._fallback_overrides.headers = overrides.get(
+            "headers", self._fallback_overrides.headers
+        )
+        post_data = overrides.get("postData")
+        if isinstance(post_data, str):
+            self._fallback_overrides.post_data_buffer = post_data.encode()
+        elif isinstance(post_data, bytes):
+            self._fallback_overrides.post_data_buffer = post_data
+        elif post_data is not None:
+            self._fallback_overrides.post_data_buffer = json.dumps(post_data).encode()
 
     @property
     def url(self) -> str:
-        return self._initializer["url"]
+        return cast(str, self._fallback_overrides.url or self._initializer["url"])
 
     @property
-    def resourceType(self) -> str:
+    def resource_type(self) -> str:
         return self._initializer["resourceType"]
 
+    @property
+    def service_worker(self) -> Optional["Worker"]:
+        return cast(
+            Optional["Worker"],
+            from_nullable_channel(self._initializer.get("serviceWorker")),
+        )
+
     @property
     def method(self) -> str:
-        return self._initializer["method"]
+        return cast(str, self._fallback_overrides.method or self._initializer["method"])
+
+    async def sizes(self) -> RequestSizes:
+        response = await self.response()
+        if not response:
+            raise Error("Unable to fetch sizes for failed request")
+        return await response._channel.send(
+            "sizes",
+            None,
+        )
 
     @property
-    def postData(self) -> Optional[str]:
-        data = self.postDataBuffer
-        if not data:
-            return None
-        return data.decode()
+    def post_data(self) -> Optional[str]:
+        data = self._fallback_overrides.post_data_buffer
+        if data:
+            return data.decode()
+        base64_post_data = self._initializer.get("postData")
+        if base64_post_data is not None:
+            return base64.b64decode(base64_post_data).decode()
+        return None
 
     @property
-    def postDataJSON(self) -> Optional[Dict]:
-        post_data = self.postData
+    def post_data_json(self) -> Optional[Any]:
+        post_data = self.post_data
         if not post_data:
             return None
         content_type = self.headers["content-type"]
-        if not content_type:
-            return None
-        if content_type == "application/x-www-form-urlencoded":
+        if "application/x-www-form-urlencoded" in content_type:
             return dict(parse.parse_qsl(post_data))
-        return json.loads(post_data)
+        try:
+            return json.loads(post_data)
+        except Exception:
+            raise Error(f"POST data is not a valid JSON object: {post_data}")
 
     @property
-    def postDataBuffer(self) -> Optional[bytes]:
-        b64_content = self._initializer.get("postData")
-        if not b64_content:
-            return None
-        return base64.b64decode(b64_content)
-
-    @property
-    def headers(self) -> Dict[str, str]:
-        return self._headers
+    def post_data_buffer(self) -> Optional[bytes]:
+        if self._fallback_overrides.post_data_buffer:
+            return self._fallback_overrides.post_data_buffer
+        if self._initializer.get("postData"):
+            return base64.b64decode(self._initializer["postData"])
+        return None
 
     async def response(self) -> Optional["Response"]:
-        return from_nullable_channel(await self._channel.send("response"))
+        return from_nullable_channel(
+            await self._channel.send(
+                "response",
+                None,
+            )
+        )
 
     @property
-    def frame(self) -> "Frame":
-        return from_channel(self._initializer["frame"])
+    def existing_response(self) -> Optional["Response"]:
+        return self._response
 
     @property
-    def isNavigationRequest(self) -> bool:
+    def frame(self) -> "Frame":
+        if not self._initializer.get("frame"):
+            raise Error("Service Worker requests do not have an associated frame.")
+        frame = cast("Frame", from_channel(self._initializer["frame"]))
+        if not frame._page:
+            raise Error(
+                "\n".join(
+                    [
+                        "Frame for this navigation request is not available, because the request",
+                        "was issued before the frame is created. You can check whether the request",
+                        "is a navigation request by calling isNavigationRequest() method.",
+                    ]
+                )
+            )
+        return frame
+
+    def is_navigation_request(self) -> bool:
         return self._initializer["isNavigationRequest"]
 
     @property
-    def redirectedFrom(self) -> Optional["Request"]:
+    def redirected_from(self) -> Optional["Request"]:
         return self._redirected_from
 
     @property
-    def redirectedTo(self) -> Optional["Request"]:
+    def redirected_to(self) -> Optional["Request"]:
         return self._redirected_to
 
     @property
@@ -129,29 +284,149 @@ def failure(self) -> Optional[str]:
     def timing(self) -> ResourceTiming:
         return self._timing
 
+    def _set_response_end_timing(self, response_end_timing: float) -> None:
+        self._timing["responseEnd"] = response_end_timing
+        if self._timing["responseStart"] == -1:
+            self._timing["responseStart"] = response_end_timing
+
+    @property
+    def headers(self) -> Headers:
+        override = self._fallback_overrides.headers
+        if override:
+            return RawHeaders._from_headers_dict_lossy(override).headers()
+        return self._provisional_headers.headers()
+
+    async def all_headers(self) -> Headers:
+        return (await self._actual_headers()).headers()
+
+    async def headers_array(self) -> HeadersArray:
+        return (await self._actual_headers()).headers_array()
+
+    async def header_value(self, name: str) -> Optional[str]:
+        return (await self._actual_headers()).get(name)
+
+    async def _actual_headers(self) -> "RawHeaders":
+        override = self._fallback_overrides.headers
+        if override:
+            return RawHeaders(serialize_headers(override))
+        if not self._all_headers_future:
+            self._all_headers_future = asyncio.Future()
+            headers = await self._channel.send(
+                "rawRequestHeaders", None, is_internal=True
+            )
+            self._all_headers_future.set_result(RawHeaders(headers))
+        return await self._all_headers_future
+
+    def _target_closed_future(self) -> asyncio.Future:
+        frame = cast(
+            Optional["Frame"], from_nullable_channel(self._initializer.get("frame"))
+        )
+        if not frame:
+            return asyncio.Future()
+        page = frame._page
+        if not page:
+            return asyncio.Future()
+        return page._closed_or_crashed_future
+
+    def _safe_page(self) -> "Optional[Page]":
+        frame = from_nullable_channel(self._initializer.get("frame"))
+        if not frame:
+            return None
+        return cast("Frame", frame)._page
+
 
 class Route(ChannelOwner):
     def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        self._handling_future: Optional[asyncio.Future["bool"]] = None
+        self._context: "BrowserContext" = cast("BrowserContext", None)
+        self._did_throw = False
+
+    def _start_handling(self) -> "asyncio.Future[bool]":
+        self._handling_future = asyncio.Future()
+        return self._handling_future
+
+    def _report_handled(self, done: bool) -> None:
+        chain = self._handling_future
+        assert chain
+        self._handling_future = None
+        chain.set_result(done)
+
+    def _check_not_handled(self) -> None:
+        if not self._handling_future:
+            raise Error("Route is already handled!")
+
+    def __repr__(self) -> str:
+        return f"<Route request={self.request}>"
 
     @property
     def request(self) -> Request:
         return from_channel(self._initializer["request"])
 
     async def abort(self, errorCode: str = None) -> None:
-        await self._channel.send("abort", locals_to_params(locals()))
+        await self._handle_route(
+            lambda: self._race_with_page_close(
+                self._channel.send(
+                    "abort",
+                    None,
+                    {
+                        "errorCode": errorCode,
+                    },
+                )
+            )
+        )
 
     async def fulfill(
         self,
         status: int = None,
         headers: Dict[str, str] = None,
         body: Union[str, bytes] = None,
+        json: Any = None,
         path: Union[str, Path] = None,
         contentType: str = None,
+        response: "APIResponse" = None,
+    ) -> None:
+        await self._handle_route(
+            lambda: self._inner_fulfill(
+                status, headers, body, json, path, contentType, response
+            )
+        )
+
+    async def _inner_fulfill(
+        self,
+        status: int = None,
+        headers: Dict[str, str] = None,
+        body: Union[str, bytes] = None,
+        json: Any = None,
+        path: Union[str, Path] = None,
+        contentType: str = None,
+        response: "APIResponse" = None,
     ) -> None:
         params = locals_to_params(locals())
+
+        if json is not None:
+            if body is not None:
+                raise Error("Can specify either body or json parameters")
+            body = json_utils.dumps(json)
+
+        if response:
+            del params["response"]
+            params["status"] = (
+                params["status"] if params.get("status") else response.status
+            )
+            params["headers"] = (
+                params["headers"] if params.get("headers") else response.headers
+            )
+            from playwright._impl._fetch import APIResponse
+
+            if body is None and path is None and isinstance(response, APIResponse):
+                if response._request._connection is self._connection:
+                    params["fetchResponseUid"] = response._fetch_uid
+                else:
+                    body = await response.body()
+
         length = 0
         if isinstance(body, str):
             params["body"] = body
@@ -171,6 +446,8 @@ async def fulfill(
         headers = {k.lower(): str(v) for k, v in params.get("headers", {}).items()}
         if params.get("contentType"):
             headers["content-type"] = params["contentType"]
+        elif json:
+            headers["content-type"] = "application/json"
         elif path:
             headers["content-type"] = (
                 mimetypes.guess_type(str(Path(path)))[0] or "application/octet-stream"
@@ -178,27 +455,355 @@ async def fulfill(
         if length and "content-length" not in headers:
             headers["content-length"] = str(length)
         params["headers"] = serialize_headers(headers)
-        await self._channel.send("fulfill", params)
+
+        await self._race_with_page_close(self._channel.send("fulfill", None, params))
+
+    async def _handle_route(self, callback: Callable) -> None:
+        self._check_not_handled()
+        try:
+            await callback()
+            self._report_handled(True)
+        except Exception as e:
+            self._did_throw = True
+            raise e
+
+    async def fetch(
+        self,
+        url: str = None,
+        method: str = None,
+        headers: Dict[str, str] = None,
+        postData: Union[Any, str, bytes] = None,
+        maxRedirects: int = None,
+        maxRetries: int = None,
+        timeout: float = None,
+    ) -> "APIResponse":
+        return await self._connection.wrap_api_call(
+            lambda: self._context.request._inner_fetch(
+                self.request,
+                url,
+                method,
+                headers,
+                postData,
+                maxRedirects=maxRedirects,
+                maxRetries=maxRetries,
+                timeout=timeout,
+            )
+        )
+
+    async def fallback(
+        self,
+        url: str = None,
+        method: str = None,
+        headers: Dict[str, str] = None,
+        postData: Union[Any, str, bytes] = None,
+    ) -> None:
+        overrides = cast(FallbackOverrideParameters, locals_to_params(locals()))
+        self._check_not_handled()
+        self.request._apply_fallback_overrides(overrides)
+        self._report_handled(False)
 
     async def continue_(
         self,
         url: str = None,
         method: str = None,
         headers: Dict[str, str] = None,
-        postData: Union[str, bytes] = None,
+        postData: Union[Any, str, bytes] = None,
+    ) -> None:
+        overrides = cast(FallbackOverrideParameters, locals_to_params(locals()))
+
+        async def _inner() -> None:
+            self.request._apply_fallback_overrides(overrides)
+            await self._inner_continue(False)
+
+        return await self._handle_route(_inner)
+
+    async def _inner_continue(self, is_fallback: bool = False) -> None:
+        options = self.request._fallback_overrides
+        await self._race_with_page_close(
+            self._channel.send(
+                "continue",
+                None,
+                {
+                    "url": options.url,
+                    "method": options.method,
+                    "headers": (
+                        serialize_headers(options.headers) if options.headers else None
+                    ),
+                    "postData": (
+                        base64.b64encode(options.post_data_buffer).decode()
+                        if options.post_data_buffer is not None
+                        else None
+                    ),
+                    "isFallback": is_fallback,
+                },
+            )
+        )
+
+    async def _redirected_navigation_request(self, url: str) -> None:
+        await self._handle_route(
+            lambda: self._race_with_page_close(
+                self._channel.send("redirectNavigationRequest", None, {"url": url})
+            )
+        )
+
+    async def _race_with_page_close(self, future: Coroutine) -> None:
+        fut = asyncio.create_task(future)
+        # Rewrite the user's stack to the new task which runs in the background.
+        setattr(
+            fut,
+            "__pw_stack__",
+            getattr(asyncio.current_task(self._loop), "__pw_stack__", inspect.stack(0)),
+        )
+        target_closed_future = self.request._target_closed_future()
+        await asyncio.wait(
+            [fut, target_closed_future],
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        if fut.done() and fut.exception():
+            raise cast(BaseException, fut.exception())
+        if target_closed_future.done():
+            await asyncio.gather(fut, return_exceptions=True)
+
+
+def _create_task_and_ignore_exception(
+    loop: asyncio.AbstractEventLoop, coro: Coroutine
+) -> None:
+    async def _ignore_exception() -> None:
+        try:
+            await coro
+        except Exception:
+            pass
+
+    loop.create_task(_ignore_exception())
+
+
+class ServerWebSocketRoute:
+    def __init__(self, ws: "WebSocketRoute"):
+        self._ws = ws
+
+    def on_message(self, handler: Callable[[Union[str, bytes]], Any]) -> None:
+        self._ws._on_server_message = handler
+
+    def on_close(self, handler: Callable[[Optional[int], Optional[str]], Any]) -> None:
+        self._ws._on_server_close = handler
+
+    def connect_to_server(self) -> None:
+        raise NotImplementedError(
+            "connectToServer must be called on the page-side WebSocketRoute"
+        )
+
+    @property
+    def url(self) -> str:
+        return self._ws._initializer["url"]
+
+    @property
+    def protocols(self) -> List[str]:
+        return list(self._ws._initializer.get("protocols", []))
+
+    def close(self, code: int = None, reason: str = None) -> None:
+        _create_task_and_ignore_exception(
+            self._ws._loop,
+            self._ws._channel.send(
+                "closeServer",
+                None,
+                {
+                    "code": code,
+                    "reason": reason,
+                    "wasClean": True,
+                },
+            ),
+        )
+
+    def send(self, message: Union[str, bytes]) -> None:
+        if isinstance(message, str):
+            _create_task_and_ignore_exception(
+                self._ws._loop,
+                self._ws._channel.send(
+                    "sendToServer", None, {"message": message, "isBase64": False}
+                ),
+            )
+        else:
+            _create_task_and_ignore_exception(
+                self._ws._loop,
+                self._ws._channel.send(
+                    "sendToServer",
+                    None,
+                    {"message": base64.b64encode(message).decode(), "isBase64": True},
+                ),
+            )
+
+
+class WebSocketRoute(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
-        overrides: ContinueParameters = {}
-        if url:
-            overrides["url"] = url
-        if method:
-            overrides["method"] = method
-        if headers:
-            overrides["headers"] = serialize_headers(headers)
-        if isinstance(postData, str):
-            overrides["postData"] = base64.b64encode(postData.encode()).decode()
-        elif isinstance(postData, bytes):
-            overrides["postData"] = base64.b64encode(postData).decode()
-        await self._channel.send("continue", cast(Any, overrides))
+        super().__init__(parent, type, guid, initializer)
+        self._on_page_message: Optional[Callable[[Union[str, bytes]], Any]] = None
+        self._on_page_close: Optional[Callable[[Optional[int], Optional[str]], Any]] = (
+            None
+        )
+        self._on_server_message: Optional[Callable[[Union[str, bytes]], Any]] = None
+        self._on_server_close: Optional[
+            Callable[[Optional[int], Optional[str]], Any]
+        ] = None
+        self._server = ServerWebSocketRoute(self)
+        self._connected = False
+
+        self._channel.on("messageFromPage", self._channel_message_from_page)
+        self._channel.on("messageFromServer", self._channel_message_from_server)
+        self._channel.on("closePage", self._channel_close_page)
+        self._channel.on("closeServer", self._channel_close_server)
+
+    def _channel_message_from_page(self, event: Dict) -> None:
+        if self._on_page_message:
+            self._on_page_message(
+                base64.b64decode(event["message"])
+                if event["isBase64"]
+                else event["message"]
+            )
+        elif self._connected:
+            _create_task_and_ignore_exception(
+                self._loop, self._channel.send("sendToServer", None, event)
+            )
+
+    def _channel_message_from_server(self, event: Dict) -> None:
+        if self._on_server_message:
+            self._on_server_message(
+                base64.b64decode(event["message"])
+                if event["isBase64"]
+                else event["message"]
+            )
+        else:
+            _create_task_and_ignore_exception(
+                self._loop, self._channel.send("sendToPage", None, event)
+            )
+
+    def _channel_close_page(self, event: Dict) -> None:
+        if self._on_page_close:
+            self._on_page_close(event["code"], event["reason"])
+        else:
+            _create_task_and_ignore_exception(
+                self._loop, self._channel.send("closeServer", None, event)
+            )
+
+    def _channel_close_server(self, event: Dict) -> None:
+        if self._on_server_close:
+            self._on_server_close(event["code"], event["reason"])
+        else:
+            _create_task_and_ignore_exception(
+                self._loop, self._channel.send("closePage", None, event)
+            )
+
+    @property
+    def url(self) -> str:
+        return self._initializer["url"]
+
+    @property
+    def protocols(self) -> List[str]:
+        return list(self._initializer.get("protocols", []))
+
+    async def close(self, code: int = None, reason: str = None) -> None:
+        try:
+            await self._channel.send(
+                "closePage", None, {"code": code, "reason": reason, "wasClean": True}
+            )
+        except Exception:
+            pass
+
+    def connect_to_server(self) -> "WebSocketRoute":
+        if self._connected:
+            raise Error("Already connected to the server")
+        self._connected = True
+        asyncio.create_task(
+            self._channel.send(
+                "connect",
+                None,
+            )
+        )
+        return cast("WebSocketRoute", self._server)
+
+    def send(self, message: Union[str, bytes]) -> None:
+        if isinstance(message, str):
+            _create_task_and_ignore_exception(
+                self._loop,
+                self._channel.send(
+                    "sendToPage", None, {"message": message, "isBase64": False}
+                ),
+            )
+        else:
+            _create_task_and_ignore_exception(
+                self._loop,
+                self._channel.send(
+                    "sendToPage",
+                    None,
+                    {
+                        "message": base64.b64encode(message).decode(),
+                        "isBase64": True,
+                    },
+                ),
+            )
+
+    def on_message(self, handler: Callable[[Union[str, bytes]], Any]) -> None:
+        self._on_page_message = handler
+
+    def on_close(self, handler: Callable[[Optional[int], Optional[str]], Any]) -> None:
+        self._on_page_close = handler
+
+    async def _after_handle(self) -> None:
+        if self._connected:
+            return
+        # Ensure that websocket is "open" and can send messages without an actual server connection.
+        try:
+            await self._channel.send(
+                "ensureOpened",
+                None,
+            )
+        except Exception:
+            pass
+
+
+class WebSocketRouteHandler:
+    def __init__(
+        self,
+        base_url: Optional[str],
+        url: URLMatch,
+        handler: WebSocketRouteHandlerCallback,
+    ):
+        self._base_url = base_url
+        self.url = url
+        self.handler = handler
+
+    @staticmethod
+    def prepare_interception_patterns(
+        handlers: List["WebSocketRouteHandler"],
+    ) -> List[dict]:
+        patterns = []
+        all_urls = False
+        for handler in handlers:
+            if isinstance(handler.url, str):
+                patterns.append({"glob": handler.url})
+            elif isinstance(handler.url, re.Pattern):
+                patterns.append(
+                    {
+                        "regexSource": handler.url.pattern,
+                        "regexFlags": escape_regex_flags(handler.url),
+                    }
+                )
+            else:
+                all_urls = True
+
+        if all_urls:
+            return [{"glob": "**/*"}]
+        return patterns
+
+    def matches(self, ws_url: str) -> bool:
+        return url_matches(self._base_url, ws_url, self.url, True)
+
+    async def handle(self, websocket_route: "WebSocketRoute") -> None:
+        coro_or_future = self.handler(websocket_route)
+        if asyncio.iscoroutine(coro_or_future):
+            await coro_or_future
+        await websocket_route._after_handle()
 
 
 class Response(ChannelOwner):
@@ -207,6 +812,7 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
         self._request: Request = from_channel(self._initializer["request"])
+        self._request._response = self
         timing = self._initializer["timing"]
         self._request._timing["startTime"] = timing["startTime"]
         self._request._timing["domainLookupStart"] = timing["domainLookupStart"]
@@ -216,7 +822,14 @@ def __init__(
         self._request._timing["connectEnd"] = timing["connectEnd"]
         self._request._timing["requestStart"] = timing["requestStart"]
         self._request._timing["responseStart"] = timing["responseStart"]
-        self._request._headers = parse_headers(self._initializer["requestHeaders"])
+        self._provisional_headers = RawHeaders(
+            cast(HeadersArray, self._initializer["headers"])
+        )
+        self._raw_headers_future: Optional[asyncio.Future[RawHeaders]] = None
+        self._finished_future: asyncio.Future[bool] = asyncio.Future()
+
+    def __repr__(self) -> str:
+        return f"<Response url={self.url!r} request={self.request}>"
 
     @property
     def url(self) -> str:
@@ -224,6 +837,7 @@ def url(self) -> str:
 
     @property
     def ok(self) -> bool:
+        # Status 0 is for file:// URLs
         return self._initializer["status"] == 0 or (
             self._initializer["status"] >= 200 and self._initializer["status"] <= 299
         )
@@ -233,25 +847,88 @@ def status(self) -> int:
         return self._initializer["status"]
 
     @property
-    def statusText(self) -> str:
+    def status_text(self) -> str:
         return self._initializer["statusText"]
 
     @property
-    def headers(self) -> Dict[str, str]:
-        return parse_headers(self._initializer["headers"])
+    def headers(self) -> Headers:
+        return self._provisional_headers.headers()
+
+    @property
+    def from_service_worker(self) -> bool:
+        return self._initializer["fromServiceWorker"]
+
+    async def all_headers(self) -> Headers:
+        return (await self._actual_headers()).headers()
+
+    async def headers_array(self) -> HeadersArray:
+        return (await self._actual_headers()).headers_array()
+
+    async def header_value(self, name: str) -> Optional[str]:
+        return (await self._actual_headers()).get(name)
+
+    async def header_values(self, name: str) -> List[str]:
+        return (await self._actual_headers()).get_all(name)
+
+    async def _actual_headers(self) -> "RawHeaders":
+        if not self._raw_headers_future:
+            self._raw_headers_future = asyncio.Future()
+            headers = cast(
+                HeadersArray,
+                await self._channel.send(
+                    "rawResponseHeaders",
+                    None,
+                ),
+            )
+            self._raw_headers_future.set_result(RawHeaders(headers))
+        return await self._raw_headers_future
+
+    async def server_addr(self) -> Optional[RemoteAddr]:
+        return await self._channel.send(
+            "serverAddr",
+            None,
+        )
+
+    async def security_details(self) -> Optional[SecurityDetails]:
+        return await self._channel.send(
+            "securityDetails",
+            None,
+        )
+
+    async def http_version(self) -> str:
+        return await self._channel.send(
+            "httpVersion",
+            None,
+        )
 
-    async def finished(self) -> Optional[str]:
-        return await self._channel.send("finished")
+    async def finished(self) -> None:
+        async def on_finished() -> None:
+            await self._request._target_closed_future()
+            raise Error("Target closed")
+
+        on_finished_task = asyncio.create_task(on_finished())
+        await asyncio.wait(
+            cast(
+                List[Union[asyncio.Task, asyncio.Future]],
+                [self._finished_future, on_finished_task],
+            ),
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        if on_finished_task.done():
+            await on_finished_task
 
     async def body(self) -> bytes:
-        binary = await self._channel.send("body")
+        binary = await self._channel.send(
+            "body",
+            None,
+        )
         return base64.b64decode(binary)
 
     async def text(self) -> str:
         content = await self.body()
         return content.decode()
 
-    async def json(self) -> Union[Dict, List]:
+    async def json(self) -> Any:
         return json.loads(await self.text())
 
     @property
@@ -264,7 +941,6 @@ def frame(self) -> "Frame":
 
 
 class WebSocket(ChannelOwner):
-
     Events = SimpleNamespace(
         Close="close",
         FrameReceived="framereceived",
@@ -277,6 +953,7 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
         self._is_closed = False
+        self._page = cast("Page", parent)
         self._channel.on(
             "frameSent",
             lambda params: self._on_frame_sent(params["opcode"], params["data"]),
@@ -286,65 +963,94 @@ def __init__(
             lambda params: self._on_frame_received(params["opcode"], params["data"]),
         )
         self._channel.on(
-            "error", lambda params: self.emit(WebSocket.Events.Error, params["error"])
+            "socketError",
+            lambda params: self.emit(WebSocket.Events.Error, params["error"]),
         )
         self._channel.on("close", lambda params: self._on_close())
 
+    def __repr__(self) -> str:
+        return f"<WebSocket url={self.url!r}>"
+
     @property
     def url(self) -> str:
         return self._initializer["url"]
 
-    async def waitForEvent(
-        self, event: str, predicate: Callable[[Any], bool] = None, timeout: int = None
-    ) -> Any:
+    def expect_event(
+        self,
+        event: str,
+        predicate: Callable = None,
+        timeout: float = None,
+    ) -> EventContextManagerImpl:
         if timeout is None:
             timeout = cast(Any, self._parent)._timeout_settings.timeout()
-        wait_helper = WaitHelper(self._loop)
-        wait_helper.reject_on_timeout(
-            timeout, f'Timeout while waiting for event "{event}"'
+        waiter = Waiter(self, f"web_socket.expect_event({event})")
+        waiter.reject_on_timeout(
+            cast(float, timeout),
+            f'Timeout {timeout}ms exceeded while waiting for event "{event}"',
         )
         if event != WebSocket.Events.Close:
-            wait_helper.reject_on_event(
-                self, WebSocket.Events.Close, Error("Socket closed")
-            )
+            waiter.reject_on_event(self, WebSocket.Events.Close, Error("Socket closed"))
         if event != WebSocket.Events.Error:
-            wait_helper.reject_on_event(
-                self, WebSocket.Events.Error, Error("Socket error")
-            )
-        wait_helper.reject_on_event(self._parent, "close", Error("Page closed"))
-        return await wait_helper.wait_for_event(self, event, predicate)
+            waiter.reject_on_event(self, WebSocket.Events.Error, Error("Socket error"))
+        waiter.reject_on_event(
+            self._page, "close", lambda: self._page._close_error_with_reason()
+        )
+        waiter.wait_for_event(self, event, predicate)
+        return EventContextManagerImpl(waiter.result())
 
-    def expect_event(
-        self,
-        event: str,
-        predicate: Callable[[Any], bool] = None,
-        timeout: int = None,
-    ) -> EventContextManagerImpl:
-        return EventContextManagerImpl(self.waitForEvent(event, predicate, timeout))
+    async def wait_for_event(
+        self, event: str, predicate: Callable = None, timeout: float = None
+    ) -> Any:
+        async with self.expect_event(event, predicate, timeout) as event_info:
+            pass
+        return await event_info
 
     def _on_frame_sent(self, opcode: int, data: str) -> None:
         if opcode == 2:
             self.emit(WebSocket.Events.FrameSent, base64.b64decode(data))
-        else:
+        elif opcode == 1:
             self.emit(WebSocket.Events.FrameSent, data)
 
     def _on_frame_received(self, opcode: int, data: str) -> None:
         if opcode == 2:
             self.emit(WebSocket.Events.FrameReceived, base64.b64decode(data))
-        else:
+        elif opcode == 1:
             self.emit(WebSocket.Events.FrameReceived, data)
 
-    def isClosed(self) -> bool:
+    def is_closed(self) -> bool:
         return self._is_closed
 
     def _on_close(self) -> None:
         self._is_closed = True
-        self.emit(WebSocket.Events.Close)
+        self.emit(WebSocket.Events.Close, self)
+
+
+class RawHeaders:
+    def __init__(self, headers: HeadersArray) -> None:
+        self._headers_array = headers
+        self._headers_map: Dict[str, Dict[str, bool]] = defaultdict(dict)
+        for header in headers:
+            self._headers_map[header["name"].lower()][header["value"]] = True
 
+    @staticmethod
+    def _from_headers_dict_lossy(headers: Dict[str, str]) -> "RawHeaders":
+        return RawHeaders(serialize_headers(headers))
 
-def serialize_headers(headers: Dict[str, str]) -> List[Header]:
-    return [{"name": name, "value": value} for name, value in headers.items()]
+    def get(self, name: str) -> Optional[str]:
+        values = self.get_all(name)
+        if not values:
+            return None
+        separator = "\n" if name.lower() == "set-cookie" else ", "
+        return separator.join(values)
+
+    def get_all(self, name: str) -> List[str]:
+        return list(self._headers_map[name.lower()].keys())
 
+    def headers(self) -> Dict[str, str]:
+        result = {}
+        for name in self._headers_map.keys():
+            result[name] = cast(str, self.get(name))
+        return result
 
-def parse_headers(headers: List[Header]) -> Dict[str, str]:
-    return {header["name"].lower(): header["value"] for header in headers}
+    def headers_array(self) -> HeadersArray:
+        return self._headers_array
diff --git a/playwright/_impl/_object_factory.py b/playwright/_impl/_object_factory.py
index aa9c0d988..7911ddb30 100644
--- a/playwright/_impl/_object_factory.py
+++ b/playwright/_impl/_object_factory.py
@@ -12,24 +12,34 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, cast
+from typing import Dict, cast
 
+from playwright._impl._artifact import Artifact
 from playwright._impl._browser import Browser
 from playwright._impl._browser_context import BrowserContext
 from playwright._impl._browser_type import BrowserType
 from playwright._impl._cdp_session import CDPSession
-from playwright._impl._chromium_browser_context import ChromiumBrowserContext
 from playwright._impl._connection import ChannelOwner
-from playwright._impl._console_message import ConsoleMessage
+from playwright._impl._debugger import Debugger
 from playwright._impl._dialog import Dialog
-from playwright._impl._download import Download
+from playwright._impl._disposable import Disposable
 from playwright._impl._element_handle import ElementHandle
+from playwright._impl._fetch import APIRequestContext
 from playwright._impl._frame import Frame
 from playwright._impl._js_handle import JSHandle
-from playwright._impl._network import Request, Response, Route, WebSocket
+from playwright._impl._local_utils import LocalUtils
+from playwright._impl._network import (
+    Request,
+    Response,
+    Route,
+    WebSocket,
+    WebSocketRoute,
+)
 from playwright._impl._page import BindingCall, Page, Worker
 from playwright._impl._playwright import Playwright
-from playwright._impl._selectors import Selectors
+from playwright._impl._stream import Stream
+from playwright._impl._tracing import Tracing
+from playwright._impl._writable_stream import WritableStream
 
 
 class DummyObject(ChannelOwner):
@@ -41,7 +51,11 @@ def __init__(
 
 def create_remote_object(
     parent: ChannelOwner, type: str, guid: str, initializer: Dict
-) -> Any:
+) -> ChannelOwner:
+    if type == "Artifact":
+        return Artifact(parent, type, guid, initializer)
+    if type == "APIRequestContext":
+        return APIRequestContext(parent, type, guid, initializer)
     if type == "BindingCall":
         return BindingCall(parent, type, guid, initializer)
     if type == "Browser":
@@ -49,28 +63,26 @@ def create_remote_object(
     if type == "BrowserType":
         return BrowserType(parent, type, guid, initializer)
     if type == "BrowserContext":
-        browser_name: str = ""
-        if isinstance(parent, Browser):
-            browser_name = parent._browser_type.name
-        if isinstance(parent, BrowserType):
-            browser_name = parent.name
-        if browser_name == "chromium":
-            return ChromiumBrowserContext(parent, type, guid, initializer)
         return BrowserContext(parent, type, guid, initializer)
     if type == "CDPSession":
         return CDPSession(parent, type, guid, initializer)
-    if type == "ConsoleMessage":
-        return ConsoleMessage(parent, type, guid, initializer)
+    if type == "Debugger":
+        return Debugger(parent, type, guid, initializer)
     if type == "Dialog":
         return Dialog(parent, type, guid, initializer)
-    if type == "Download":
-        return Download(parent, type, guid, initializer)
+    if type == "Disposable":
+        return Disposable(parent, type, guid, initializer)
     if type == "ElementHandle":
         return ElementHandle(parent, type, guid, initializer)
     if type == "Frame":
         return Frame(parent, type, guid, initializer)
     if type == "JSHandle":
         return JSHandle(parent, type, guid, initializer)
+    if type == "LocalUtils":
+        local_utils = LocalUtils(parent, type, guid, initializer)
+        if not local_utils._connection._local_utils:
+            local_utils._connection._local_utils = local_utils
+        return local_utils
     if type == "Page":
         return Page(parent, type, guid, initializer)
     if type == "Playwright":
@@ -81,10 +93,16 @@ def create_remote_object(
         return Response(parent, type, guid, initializer)
     if type == "Route":
         return Route(parent, type, guid, initializer)
+    if type == "Stream":
+        return Stream(parent, type, guid, initializer)
+    if type == "Tracing":
+        return Tracing(parent, type, guid, initializer)
     if type == "WebSocket":
         return WebSocket(parent, type, guid, initializer)
+    if type == "WebSocketRoute":
+        return WebSocketRoute(parent, type, guid, initializer)
     if type == "Worker":
         return Worker(parent, type, guid, initializer)
-    if type == "Selectors":
-        return Selectors(parent, type, guid, initializer)
+    if type == "WritableStream":
+        return WritableStream(parent, type, guid, initializer)
     return DummyObject(parent, type, guid, initializer)
diff --git a/playwright/_impl/_page.py b/playwright/_impl/_page.py
index 79ecb7d54..9bf59c313 100644
--- a/playwright/_impl/_page.py
+++ b/playwright/_impl/_page.py
@@ -15,74 +15,122 @@
 import asyncio
 import base64
 import inspect
+import re
 import sys
 from pathlib import Path
 from types import SimpleNamespace
 from typing import (
     TYPE_CHECKING,
     Any,
+    Awaitable,
     Callable,
     Dict,
     List,
+    Literal,
     Optional,
-    Tuple,
+    Pattern,
+    Sequence,
     Union,
     cast,
 )
 
-from playwright._impl._accessibility import Accessibility
-from playwright._impl._api_types import Error, FilePayload, FloatRect, PdfMargins
+from playwright._impl._api_structures import (
+    AriaRole,
+    FilePayload,
+    FloatRect,
+    PdfMargins,
+    Position,
+    ViewportSize,
+)
+from playwright._impl._artifact import Artifact
+from playwright._impl._clock import Clock
 from playwright._impl._connection import (
     ChannelOwner,
     from_channel,
     from_nullable_channel,
 )
 from playwright._impl._console_message import ConsoleMessage
-from playwright._impl._dialog import Dialog
+from playwright._impl._disposable import Disposable, DisposableStub
 from playwright._impl._download import Download
-from playwright._impl._element_handle import ElementHandle
+from playwright._impl._element_handle import ElementHandle, determine_screenshot_type
+from playwright._impl._errors import Error, TargetClosedError, is_target_closed_error
 from playwright._impl._event_context_manager import EventContextManagerImpl
 from playwright._impl._file_chooser import FileChooser
 from playwright._impl._frame import Frame
+from playwright._impl._greenlets import LocatorHandlerGreenlet
+from playwright._impl._har_router import HarRouter
 from playwright._impl._helper import (
     ColorScheme,
+    Contrast,
     DocumentLoadState,
+    ForcedColors,
+    HarMode,
     KeyboardModifier,
     MouseButton,
-    PendingWaitEvent,
+    ReducedMotion,
+    RouteFromHarNotFoundPolicy,
     RouteHandler,
-    RouteHandlerEntry,
+    RouteHandlerCallback,
     TimeoutSettings,
     URLMatch,
-    URLMatcher,
-    is_function_body,
-    is_safe_close_error,
+    URLMatchRequest,
+    URLMatchResponse,
+    WebSocketRouteHandlerCallback,
+    async_readfile,
+    async_writefile,
     locals_to_params,
+    make_dirs_for_file,
     parse_error,
     serialize_error,
+    url_matches,
 )
 from playwright._impl._input import Keyboard, Mouse, Touchscreen
 from playwright._impl._js_handle import (
     JSHandle,
     Serializable,
+    add_source_url_to_script,
     parse_result,
     serialize_argument,
 )
-from playwright._impl._network import Request, Response, Route, serialize_headers
+from playwright._impl._network import (
+    Request,
+    Response,
+    Route,
+    WebSocketRoute,
+    WebSocketRouteHandler,
+    serialize_headers,
+)
+from playwright._impl._screencast import Screencast
 from playwright._impl._video import Video
-from playwright._impl._wait_helper import WaitHelper
-
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import Literal
-else:  # pragma: no cover
-    from typing_extensions import Literal
+from playwright._impl._waiter import Waiter
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._browser_context import BrowserContext
+    from playwright._impl._fetch import APIRequestContext
+    from playwright._impl._locator import FrameLocator, Locator
+    from playwright._impl._network import WebSocket
 
 
-class Page(ChannelOwner):
+class LocatorHandler:
+    locator: "Locator"
+    handler: Union[Callable[["Locator"], Any], Callable[..., Any]]
+    times: Union[int, None]
+
+    def __init__(
+        self, locator: "Locator", handler: Callable[..., Any], times: Union[int, None]
+    ) -> None:
+        self.locator = locator
+        self._handler = handler
+        self.times = times
+
+    def __call__(self) -> Any:
+        arg_count = len(inspect.signature(self._handler).parameters)
+        if arg_count == 0:
+            return self._handler()
+        return self._handler(self.locator)
 
+
+class Page(ChannelOwner):
     Events = SimpleNamespace(
         Close="close",
         Crash="crash",
@@ -104,7 +152,6 @@ class Page(ChannelOwner):
         WebSocket="websocket",
         Worker="worker",
     )
-    accessibility: Accessibility
     keyboard: Keyboard
     mouse: Mouse
     touchscreen: Touchscreen
@@ -113,7 +160,7 @@ def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
-        self.accessibility = Accessibility(self._channel)
+        self._browser_context = cast("BrowserContext", parent)
         self.keyboard = Keyboard(self._channel)
         self.mouse = Mouse(self._channel)
         self.touchscreen = Touchscreen(self._channel)
@@ -121,46 +168,34 @@ def __init__(
         self._main_frame: Frame = from_channel(initializer["mainFrame"])
         self._main_frame._page = self
         self._frames = [self._main_frame]
-        vs = initializer.get("viewportSize")
-        self._viewport_size: Optional[Tuple[int, int]] = (
-            (vs["width"], vs["height"]) if vs else None
-        )
+        self._viewport_size: Optional[ViewportSize] = initializer.get("viewportSize")
         self._is_closed = False
         self._workers: List["Worker"] = []
         self._bindings: Dict[str, Any] = {}
-        self._pending_wait_for_events: List[PendingWaitEvent] = []
-        self._routes: List[RouteHandlerEntry] = []
+        self._routes: List[RouteHandler] = []
+        self._web_socket_routes: List[WebSocketRouteHandler] = []
         self._owned_context: Optional["BrowserContext"] = None
-        self._timeout_settings: TimeoutSettings = TimeoutSettings(None)
-        self._video: Optional[Video] = None
+        self._timeout_settings: TimeoutSettings = TimeoutSettings(
+            self._browser_context._timeout_settings
+        )
+        self._video: Video = Video(
+            self,
+            cast(Optional[Artifact], from_nullable_channel(initializer.get("video"))),
+        )
+        self._screencast: Screencast = Screencast(self)
+        self._opener = cast("Page", from_nullable_channel(initializer.get("opener")))
+        self._close_reason: Optional[str] = None
+        self._close_was_called = False
+        self._har_routers: List[HarRouter] = []
+        self._locator_handlers: Dict[str, LocatorHandler] = {}
 
         self._channel.on(
             "bindingCall",
             lambda params: self._on_binding(from_channel(params["binding"])),
         )
         self._channel.on("close", lambda _: self._on_close())
-        self._channel.on(
-            "console",
-            lambda params: self.emit(
-                Page.Events.Console, from_channel(params["message"])
-            ),
-        )
         self._channel.on("crash", lambda _: self._on_crash())
-        self._channel.on(
-            "dialog",
-            lambda params: self.emit(
-                Page.Events.Dialog, from_channel(params["dialog"])
-            ),
-        )
-        self._channel.on(
-            "domcontentloaded", lambda _: self.emit(Page.Events.DOMContentLoaded)
-        )
-        self._channel.on(
-            "download",
-            lambda params: self.emit(
-                Page.Events.Download, from_channel(params["download"])
-            ),
-        )
+        self._channel.on("download", lambda params: self._on_download(params))
         self._channel.on(
             "fileChooser",
             lambda params: self.emit(
@@ -178,55 +213,25 @@ def __init__(
             "frameDetached",
             lambda params: self._on_frame_detached(from_channel(params["frame"])),
         )
-        self._channel.on("load", lambda _: self.emit(Page.Events.Load))
-        self._channel.on(
-            "pageError",
-            lambda params: self.emit(
-                Page.Events.PageError, parse_error(params["error"]["error"])
-            ),
-        )
-        self._channel.on(
-            "popup",
-            lambda params: self.emit(Page.Events.Popup, from_channel(params["page"])),
-        )
-        self._channel.on(
-            "request",
-            lambda params: self.emit(
-                Page.Events.Request, from_channel(params["request"])
-            ),
-        )
-        self._channel.on(
-            "requestFailed",
-            lambda params: self._on_request_failed(
-                from_channel(params["request"]),
-                params["responseEndTiming"],
-                params["failureText"],
-            ),
-        )
         self._channel.on(
-            "requestFinished",
-            lambda params: self._on_request_finished(
-                from_channel(params["request"]), params["responseEndTiming"]
-            ),
-        )
-        self._channel.on(
-            "response",
-            lambda params: self.emit(
-                Page.Events.Response, from_channel(params["response"])
+            "locatorHandlerTriggered",
+            lambda params: self._loop.create_task(
+                self._on_locator_handler_triggered(params["uid"])
             ),
         )
         self._channel.on(
             "route",
-            lambda params: self._on_route(
-                from_channel(params["route"]), from_channel(params["request"])
+            lambda params: self._loop.create_task(
+                self._on_route(from_channel(params["route"]))
             ),
         )
         self._channel.on(
-            "video",
-            lambda params: cast(Video, self.video)._set_relative_path(
-                params["relativePath"]
+            "webSocketRoute",
+            lambda params: self._loop.create_task(
+                self._on_web_socket_route(from_channel(params["webSocketRoute"]))
             ),
         )
+        self._channel.on("viewportSizeChanged", self._on_viewport_size_changed)
         self._channel.on(
             "webSocket",
             lambda params: self.emit(
@@ -236,47 +241,99 @@ def __init__(
         self._channel.on(
             "worker", lambda params: self._on_worker(from_channel(params["worker"]))
         )
+        self._closed_or_crashed_future: asyncio.Future = asyncio.Future()
+        self.on(
+            Page.Events.Close,
+            lambda _: (
+                self._closed_or_crashed_future.set_result(
+                    self._close_error_with_reason()
+                )
+                if not self._closed_or_crashed_future.done()
+                else None
+            ),
+        )
+        self.on(
+            Page.Events.Crash,
+            lambda _: (
+                self._closed_or_crashed_future.set_result(TargetClosedError())
+                if not self._closed_or_crashed_future.done()
+                else None
+            ),
+        )
 
-    def _set_browser_context(self, context: "BrowserContext") -> None:
-        self._browser_context = context
-        self._timeout_settings = TimeoutSettings(context._timeout_settings)
-
-    def _on_request_failed(
-        self,
-        request: Request,
-        response_end_timing: float,
-        failure_text: str = None,
-    ) -> None:
-        request._failure_text = failure_text
-        if request._timing:
-            request._timing["responseEnd"] = response_end_timing
-        self.emit(Page.Events.RequestFailed, request)
+        self._set_event_to_subscription_mapping(
+            {
+                Page.Events.Console: "console",
+                Page.Events.Dialog: "dialog",
+                Page.Events.Request: "request",
+                Page.Events.Response: "response",
+                Page.Events.RequestFinished: "requestFinished",
+                Page.Events.RequestFailed: "requestFailed",
+                Page.Events.FileChooser: "fileChooser",
+            }
+        )
 
-    def _on_request_finished(
-        self, request: Request, response_end_timing: float
-    ) -> None:
-        if request._timing:
-            request._timing["responseEnd"] = response_end_timing
-        self.emit(Page.Events.RequestFinished, request)
+    def __repr__(self) -> str:
+        return f"<Page url={self.url!r}>"
 
     def _on_frame_attached(self, frame: Frame) -> None:
         frame._page = self
         self._frames.append(frame)
         self.emit(Page.Events.FrameAttached, frame)
+        self._browser_context.emit("frameattached", frame)
 
     def _on_frame_detached(self, frame: Frame) -> None:
         self._frames.remove(frame)
         frame._detached = True
         self.emit(Page.Events.FrameDetached, frame)
-
-    def _on_route(self, route: Route, request: Request) -> None:
-        for handler_entry in self._routes:
-            if handler_entry.matcher.matches(request.url):
-                result = cast(Any, handler_entry.handler)(route, request)
-                if inspect.iscoroutine(result):
-                    asyncio.create_task(result)
+        self._browser_context.emit("framedetached", frame)
+
+    async def _on_route(self, route: Route) -> None:
+        route._context = self.context
+        route_handlers = self._routes.copy()
+        for route_handler in route_handlers:
+            # If the page was closed we stall all requests right away.
+            if self._close_was_called or self.context._closing_or_closed:
                 return
-        self._browser_context._on_route(route, request)
+            if not route_handler.matches(route.request.url):
+                continue
+            if route_handler not in self._routes:
+                continue
+            if route_handler.will_expire:
+                self._routes.remove(route_handler)
+            try:
+                handled = await route_handler.handle(route)
+            finally:
+                if len(self._routes) == 0:
+
+                    async def _update_interceptor_patterns_ignore_exceptions() -> None:
+                        try:
+                            await self._update_interception_patterns()
+                        except Error:
+                            pass
+
+                    asyncio.create_task(
+                        self._connection.wrap_api_call(
+                            _update_interceptor_patterns_ignore_exceptions, True
+                        )
+                    )
+            if handled:
+                return
+        await self._browser_context._on_route(route)
+
+    async def _on_web_socket_route(self, web_socket_route: WebSocketRoute) -> None:
+        route_handler = next(
+            (
+                route_handler
+                for route_handler in self._web_socket_routes
+                if route_handler.matches(web_socket_route.url)
+            ),
+            None,
+        )
+        if route_handler:
+            await route_handler.handle(web_socket_route)
+        else:
+            await self._browser_context._on_web_socket_route(web_socket_route)
 
     def _on_binding(self, binding_call: "BindingCall") -> None:
         func = self._bindings.get(binding_call._initializer["name"])
@@ -291,153 +348,188 @@ def _on_worker(self, worker: "Worker") -> None:
 
     def _on_close(self) -> None:
         self._is_closed = True
-        self._browser_context._pages.remove(self)
-        self._reject_pending_operations(False)
-        self.emit(Page.Events.Close)
+        if self in self._browser_context._pages:
+            self._browser_context._pages.remove(self)
+        self._dispose_har_routers()
+        self.emit(Page.Events.Close, self)
+        self._browser_context.emit("pageclose", self)
 
     def _on_crash(self) -> None:
-        self._reject_pending_operations(True)
-        self.emit(Page.Events.Crash)
-
-    def _reject_pending_operations(self, is_crash: bool) -> None:
-        for pending_event in self._pending_wait_for_events:
-            pending_event.reject(is_crash, "Page")
+        self.emit(Page.Events.Crash, self)
 
-    def _add_event_handler(self, event: str, k: Any, v: Any) -> None:
-        if event == Page.Events.FileChooser and len(self.listeners(event)) == 0:
-            self._channel.send_no_reply(
-                "setFileChooserInterceptedNoReply", {"intercepted": True}
-            )
-        super()._add_event_handler(event, k, v)
+    def _on_download(self, params: Any) -> None:
+        url = params["url"]
+        suggested_filename = params["suggestedFilename"]
+        artifact = cast(Artifact, from_channel(params["artifact"]))
+        download = Download(self, url, suggested_filename, artifact)
+        self.emit(Page.Events.Download, download)
+        self._browser_context.emit("download", download)
 
-    def remove_listener(self, event: str, f: Any) -> None:
-        super().remove_listener(event, f)
-        if event == Page.Events.FileChooser and len(self.listeners(event)) == 0:
-            self._channel.send_no_reply(
-                "setFileChooserInterceptedNoReply", {"intercepted": False}
-            )
+    def _on_viewport_size_changed(self, params: Any) -> None:
+        self._viewport_size = params["viewportSize"]
 
     @property
     def context(self) -> "BrowserContext":
         return self._browser_context
 
+    @property
+    def clock(self) -> Clock:
+        return self._browser_context.clock
+
     async def opener(self) -> Optional["Page"]:
-        return from_nullable_channel(await self._channel.send("opener"))
+        if self._opener and self._opener.is_closed():
+            return None
+        return self._opener
 
     @property
-    def mainFrame(self) -> Frame:
+    def main_frame(self) -> Frame:
         return self._main_frame
 
     def frame(self, name: str = None, url: URLMatch = None) -> Optional[Frame]:
-        matcher = URLMatcher(url) if url else None
         for frame in self._frames:
             if name and frame.name == name:
                 return frame
-            if url and matcher and matcher.matches(frame.url):
+            if url and url_matches(self._browser_context._base_url, frame.url, url):
                 return frame
+
         return None
 
     @property
     def frames(self) -> List[Frame]:
         return self._frames.copy()
 
-    def setDefaultNavigationTimeout(self, timeout: int) -> None:
-        self._timeout_settings.set_navigation_timeout(timeout)
-        self._channel.send_no_reply(
-            "setDefaultNavigationTimeoutNoReply", dict(timeout=timeout)
-        )
+    def set_default_navigation_timeout(self, timeout: float) -> None:
+        self._timeout_settings.set_default_navigation_timeout(timeout)
 
-    def setDefaultTimeout(self, timeout: int) -> None:
-        self._timeout_settings.set_timeout(timeout)
-        self._channel.send_no_reply("setDefaultTimeoutNoReply", dict(timeout=timeout))
+    def set_default_timeout(self, timeout: float) -> None:
+        self._timeout_settings.set_default_timeout(timeout)
 
-    async def querySelector(self, selector: str) -> Optional[ElementHandle]:
-        return await self._main_frame.querySelector(selector)
+    async def query_selector(
+        self,
+        selector: str,
+        strict: bool = None,
+    ) -> Optional[ElementHandle]:
+        return await self._main_frame.query_selector(selector, strict)
 
-    async def querySelectorAll(self, selector: str) -> List[ElementHandle]:
-        return await self._main_frame.querySelectorAll(selector)
+    async def query_selector_all(self, selector: str) -> List[ElementHandle]:
+        return await self._main_frame.query_selector_all(selector)
 
-    async def waitForSelector(
+    async def wait_for_selector(
         self,
         selector: str,
-        timeout: int = None,
+        timeout: float = None,
         state: Literal["attached", "detached", "hidden", "visible"] = None,
+        strict: bool = None,
     ) -> Optional[ElementHandle]:
-        return await self._main_frame.waitForSelector(**locals_to_params(locals()))
-
-    async def dispatchEvent(
-        self, selector: str, type: str, eventInit: Dict = None, timeout: int = None
+        return await self._main_frame.wait_for_selector(**locals_to_params(locals()))
+
+    async def is_checked(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._main_frame.is_checked(**locals_to_params(locals()))
+
+    async def is_disabled(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._main_frame.is_disabled(**locals_to_params(locals()))
+
+    async def is_editable(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._main_frame.is_editable(**locals_to_params(locals()))
+
+    async def is_enabled(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        return await self._main_frame.is_enabled(**locals_to_params(locals()))
+
+    async def is_hidden(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        # timeout is deprecated and does nothing
+        return await self._main_frame.is_hidden(selector=selector, strict=strict)
+
+    async def is_visible(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> bool:
+        # timeout is deprecated and does nothing
+        return await self._main_frame.is_visible(selector=selector, strict=strict)
+
+    async def dispatch_event(
+        self,
+        selector: str,
+        type: str,
+        eventInit: Dict = None,
+        timeout: float = None,
+        strict: bool = None,
     ) -> None:
-        return await self._main_frame.dispatchEvent(**locals_to_params(locals()))
+        return await self._main_frame.dispatch_event(**locals_to_params(locals()))
 
-    async def evaluate(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
-    ) -> Any:
-        return await self._main_frame.evaluate(expression, arg, force_expr=force_expr)
+    async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
+        return await self._main_frame.evaluate(expression, arg)
 
-    async def evaluateHandle(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
+    async def evaluate_handle(
+        self, expression: str, arg: Serializable = None
     ) -> JSHandle:
-        return await self._main_frame.evaluateHandle(
-            expression, arg, force_expr=force_expr
-        )
+        return await self._main_frame.evaluate_handle(expression, arg)
 
-    async def evalOnSelector(
+    async def eval_on_selector(
         self,
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
+        strict: bool = None,
     ) -> Any:
-        return await self._main_frame.evalOnSelector(
-            selector, expression, arg, force_expr=force_expr
+        return await self._main_frame.eval_on_selector(
+            selector, expression, arg, strict
         )
 
-    async def evalOnSelectorAll(
+    async def eval_on_selector_all(
         self,
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
     ) -> Any:
-        return await self._main_frame.evalOnSelectorAll(
-            selector, expression, arg, force_expr=force_expr
-        )
+        return await self._main_frame.eval_on_selector_all(selector, expression, arg)
 
-    async def addScriptTag(
+    async def add_script_tag(
         self,
         url: str = None,
         path: Union[str, Path] = None,
         content: str = None,
         type: str = None,
     ) -> ElementHandle:
-        return await self._main_frame.addScriptTag(**locals_to_params(locals()))
+        return await self._main_frame.add_script_tag(**locals_to_params(locals()))
 
-    async def addStyleTag(
+    async def add_style_tag(
         self, url: str = None, path: Union[str, Path] = None, content: str = None
     ) -> ElementHandle:
-        return await self._main_frame.addStyleTag(**locals_to_params(locals()))
+        return await self._main_frame.add_style_tag(**locals_to_params(locals()))
 
-    async def exposeFunction(self, name: str, binding: Callable) -> None:
-        await self.exposeBinding(name, lambda source, *args: binding(*args))
+    async def expose_function(self, name: str, callback: Callable) -> Disposable:
+        return await self.expose_binding(name, lambda source, *args: callback(*args))
 
-    async def exposeBinding(
-        self, name: str, binding: Callable, handle: bool = None
-    ) -> None:
+    async def expose_binding(self, name: str, callback: Callable) -> Disposable:
         if name in self._bindings:
             raise Error(f'Function "{name}" has been already registered')
         if name in self._browser_context._bindings:
             raise Error(
                 f'Function "{name}" has been already registered in the browser context'
             )
-        self._bindings[name] = binding
-        await self._channel.send(
-            "exposeBinding", dict(name=name, needsHandle=handle or False)
+        self._bindings[name] = callback
+        return from_channel(
+            await self._channel.send(
+                "exposeBinding",
+                None,
+                dict(name=name),
+            )
         )
 
-    async def setExtraHTTPHeaders(self, headers: Dict[str, str]) -> None:
+    async def set_extra_http_headers(self, headers: Dict[str, str]) -> None:
         await self._channel.send(
-            "setExtraHTTPHeaders", dict(headers=serialize_headers(headers))
+            "setExtraHTTPHeaders",
+            None,
+            dict(headers=serialize_headers(headers)),
         )
 
     @property
@@ -447,18 +539,18 @@ def url(self) -> str:
     async def content(self) -> str:
         return await self._main_frame.content()
 
-    async def setContent(
+    async def set_content(
         self,
         html: str,
-        timeout: int = None,
+        timeout: float = None,
         waitUntil: DocumentLoadState = None,
     ) -> None:
-        return await self._main_frame.setContent(**locals_to_params(locals()))
+        return await self._main_frame.set_content(**locals_to_params(locals()))
 
     async def goto(
         self,
         url: str,
-        timeout: int = None,
+        timeout: float = None,
         waitUntil: DocumentLoadState = None,
         referer: str = None,
     ) -> Optional[Response]:
@@ -466,287 +558,533 @@ async def goto(
 
     async def reload(
         self,
-        timeout: int = None,
+        timeout: float = None,
         waitUntil: DocumentLoadState = None,
     ) -> Optional[Response]:
         return from_nullable_channel(
-            await self._channel.send("reload", locals_to_params(locals()))
+            await self._channel.send(
+                "reload",
+                self._timeout_settings.navigation_timeout,
+                locals_to_params(locals()),
+            )
         )
 
-    async def waitForLoadState(
-        self, state: DocumentLoadState = None, timeout: int = None
+    async def wait_for_load_state(
+        self,
+        state: Literal["domcontentloaded", "load", "networkidle"] = None,
+        timeout: float = None,
     ) -> None:
-        return await self._main_frame.waitForLoadState(**locals_to_params(locals()))
+        return await self._main_frame.wait_for_load_state(**locals_to_params(locals()))
 
-    async def waitForNavigation(
+    async def wait_for_url(
         self,
-        url: URLMatch = None,
+        url: URLMatch,
         waitUntil: DocumentLoadState = None,
-        timeout: int = None,
-    ) -> Optional[Response]:
-        return await self._main_frame.waitForNavigation(**locals_to_params(locals()))
-
-    async def waitForRequest(
-        self,
-        url: URLMatch = None,
-        predicate: Callable[[Request], bool] = None,
-        timeout: int = None,
-    ) -> Request:
-        matcher = URLMatcher(url) if url else None
-
-        def my_predicate(request: Request) -> bool:
-            if matcher:
-                return matcher.matches(request.url)
-            if predicate:
-                return predicate(request)
-            return True
-
-        return cast(
-            Request,
-            await self.waitForEvent(
-                Page.Events.Request, predicate=my_predicate, timeout=timeout
-            ),
-        )
-
-    async def waitForResponse(
-        self,
-        url: URLMatch = None,
-        predicate: Callable[[Response], bool] = None,
-        timeout: int = None,
-    ) -> Response:
-        matcher = URLMatcher(url) if url else None
-
-        def my_predicate(response: Response) -> bool:
-            if matcher:
-                return matcher.matches(response.url)
-            if predicate:
-                return predicate(response)
-            return True
-
-        return cast(
-            Response,
-            await self.waitForEvent(
-                Page.Events.Response, predicate=my_predicate, timeout=timeout
-            ),
-        )
+        timeout: float = None,
+    ) -> None:
+        return await self._main_frame.wait_for_url(**locals_to_params(locals()))
 
-    async def waitForEvent(
-        self, event: str, predicate: Callable[[Any], bool] = None, timeout: int = None
+    async def wait_for_event(
+        self, event: str, predicate: Callable = None, timeout: float = None
     ) -> Any:
-        if timeout is None:
-            timeout = self._timeout_settings.timeout()
-        wait_helper = WaitHelper(self._loop)
-        wait_helper.reject_on_timeout(
-            timeout, f'Timeout while waiting for event "{event}"'
-        )
-        if event != Page.Events.Crash:
-            wait_helper.reject_on_event(self, Page.Events.Crash, Error("Page crashed"))
-        if event != Page.Events.Close:
-            wait_helper.reject_on_event(self, Page.Events.Close, Error("Page closed"))
-        return await wait_helper.wait_for_event(self, event, predicate)
+        async with self.expect_event(event, predicate, timeout) as event_info:
+            pass
+        return await event_info
 
-    async def goBack(
+    async def go_back(
         self,
-        timeout: int = None,
+        timeout: float = None,
         waitUntil: DocumentLoadState = None,
     ) -> Optional[Response]:
         return from_nullable_channel(
-            await self._channel.send("goBack", locals_to_params(locals()))
+            await self._channel.send(
+                "goBack",
+                self._timeout_settings.navigation_timeout,
+                locals_to_params(locals()),
+            )
         )
 
-    async def goForward(
+    async def go_forward(
         self,
-        timeout: int = None,
+        timeout: float = None,
         waitUntil: DocumentLoadState = None,
     ) -> Optional[Response]:
         return from_nullable_channel(
-            await self._channel.send("goForward", locals_to_params(locals()))
+            await self._channel.send(
+                "goForward",
+                self._timeout_settings.navigation_timeout,
+                locals_to_params(locals()),
+            )
         )
 
-    async def emulateMedia(
+    async def request_gc(self) -> None:
+        await self._channel.send("requestGC", None)
+
+    async def emulate_media(
         self,
-        media: Literal["print", "screen"] = None,
+        media: Literal["null", "print", "screen"] = None,
         colorScheme: ColorScheme = None,
+        reducedMotion: ReducedMotion = None,
+        forcedColors: ForcedColors = None,
+        contrast: Contrast = None,
     ) -> None:
-        await self._channel.send("emulateMedia", locals_to_params(locals()))
+        params = locals_to_params(locals())
+        if "media" in params:
+            params["media"] = "no-override" if params["media"] == "null" else media
+        if "colorScheme" in params:
+            params["colorScheme"] = (
+                "no-override" if params["colorScheme"] == "null" else colorScheme
+            )
+        if "reducedMotion" in params:
+            params["reducedMotion"] = (
+                "no-override" if params["reducedMotion"] == "null" else reducedMotion
+            )
+        if "forcedColors" in params:
+            params["forcedColors"] = (
+                "no-override" if params["forcedColors"] == "null" else forcedColors
+            )
+        if "contrast" in params:
+            params["contrast"] = (
+                "no-override" if params["contrast"] == "null" else contrast
+            )
+        await self._channel.send("emulateMedia", None, params)
 
-    async def setViewportSize(self, width: int, height: int) -> None:
-        self._viewport_size = (width, height)
+    async def set_viewport_size(self, viewportSize: ViewportSize) -> None:
+        self._viewport_size = viewportSize
         await self._channel.send(
-            "setViewportSize", dict(viewportSize=locals_to_params(locals()))
+            "setViewportSize",
+            None,
+            locals_to_params(locals()),
         )
 
-    def viewportSize(self) -> Optional[Tuple[int, int]]:
+    @property
+    def viewport_size(self) -> Optional[ViewportSize]:
         return self._viewport_size
 
-    async def bringToFront(self) -> None:
-        await self._channel.send("bringToFront")
+    async def bring_to_front(self) -> None:
+        await self._channel.send("bringToFront", None)
 
-    async def addInitScript(
-        self, source: str = None, path: Union[str, Path] = None
-    ) -> None:
+    async def hide_highlight(self) -> None:
+        await self._channel.send("hideHighlight", None)
+
+    async def add_init_script(
+        self, script: str = None, path: Union[str, Path] = None
+    ) -> Disposable:
         if path:
-            with open(path, "r") as file:
-                source = file.read()
-        if not isinstance(source, str):
-            raise Error("Either path or source parameter must be specified")
-        await self._channel.send("addInitScript", dict(source=source))
-
-    async def route(self, url: URLMatch, handler: RouteHandler) -> None:
-        self._routes.append(RouteHandlerEntry(URLMatcher(url), handler))
-        if len(self._routes) == 1:
-            await self._channel.send(
-                "setNetworkInterceptionEnabled", dict(enabled=True)
+            script = add_source_url_to_script(
+                (await async_readfile(path)).decode(), path
             )
+        if not isinstance(script, str):
+            raise Error("Either path or script parameter must be specified")
+        return from_channel(
+            await self._channel.send("addInitScript", None, dict(source=script))
+        )
+
+    async def route(
+        self, url: URLMatch, handler: RouteHandlerCallback, times: int = None
+    ) -> DisposableStub:
+        self._routes.insert(
+            0,
+            RouteHandler(
+                self._browser_context._base_url,
+                url,
+                handler,
+                True if self._dispatcher_fiber else False,
+                times,
+            ),
+        )
+        await self._update_interception_patterns()
+        return DisposableStub(lambda: self.unroute(url, handler), self)
 
     async def unroute(
-        self, url: URLMatch, handler: Optional[RouteHandler] = None
+        self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None
     ) -> None:
-        self._routes = list(
-            filter(
-                lambda r: r.matcher.match != url or (handler and r.handler != handler),
-                self._routes,
+        removed = []
+        remaining = []
+        for route in self._routes:
+            if route.url != url or (handler and route.handler != handler):
+                remaining.append(route)
+            else:
+                removed.append(route)
+        await self._unroute_internal(removed, remaining, "default")
+
+    async def _unroute_internal(
+        self,
+        removed: List[RouteHandler],
+        remaining: List[RouteHandler],
+        behavior: Literal["default", "ignoreErrors", "wait"] = None,
+    ) -> None:
+        self._routes = remaining
+        if behavior is not None and behavior != "default":
+            await asyncio.gather(
+                *map(
+                    lambda route: route.stop(behavior),  # type: ignore
+                    removed,
+                )
             )
+        await self._update_interception_patterns()
+
+    async def route_web_socket(
+        self, url: URLMatch, handler: WebSocketRouteHandlerCallback
+    ) -> None:
+        self._web_socket_routes.insert(
+            0,
+            WebSocketRouteHandler(self._browser_context._base_url, url, handler),
         )
-        if len(self._routes) == 0:
-            await self._channel.send(
-                "setNetworkInterceptionEnabled", dict(enabled=False)
+        await self._update_web_socket_interception_patterns()
+
+    def _dispose_har_routers(self) -> None:
+        for router in self._har_routers:
+            router.dispose()
+        self._har_routers = []
+
+    async def unroute_all(
+        self, behavior: Literal["default", "ignoreErrors", "wait"] = None
+    ) -> None:
+        await self._unroute_internal(self._routes, [], behavior)
+        self._dispose_har_routers()
+
+    async def route_from_har(
+        self,
+        har: Union[Path, str],
+        url: Union[Pattern[str], str] = None,
+        notFound: RouteFromHarNotFoundPolicy = None,
+        update: bool = None,
+        updateContent: Literal["attach", "embed"] = None,
+        updateMode: HarMode = None,
+    ) -> None:
+        if update:
+            await self._browser_context._tracing._record_into_har(
+                har=har,
+                page=self,
+                url=url,
+                update_content=updateContent,
+                update_mode=updateMode,
             )
+            return
+        router = await HarRouter.create(
+            local_utils=self._connection.local_utils,
+            file=str(har),
+            not_found_action=notFound or "abort",
+            url_matcher=url,
+        )
+        self._har_routers.append(router)
+        await router.add_page_route(self)
+
+    async def _update_interception_patterns(self) -> None:
+        patterns = RouteHandler.prepare_interception_patterns(self._routes)
+        await self._channel.send(
+            "setNetworkInterceptionPatterns",
+            None,
+            {"patterns": patterns},
+        )
+
+    async def _update_web_socket_interception_patterns(self) -> None:
+        patterns = WebSocketRouteHandler.prepare_interception_patterns(
+            self._web_socket_routes
+        )
+        await self._channel.send(
+            "setWebSocketInterceptionPatterns",
+            None,
+            {"patterns": patterns},
+        )
 
     async def screenshot(
         self,
-        timeout: int = None,
+        timeout: float = None,
         type: Literal["jpeg", "png"] = None,
         path: Union[str, Path] = None,
         quality: int = None,
         omitBackground: bool = None,
         fullPage: bool = None,
         clip: FloatRect = None,
+        animations: Literal["allow", "disabled"] = None,
+        caret: Literal["hide", "initial"] = None,
+        scale: Literal["css", "device"] = None,
+        mask: Sequence["Locator"] = None,
+        maskColor: str = None,
+        style: str = None,
     ) -> bytes:
         params = locals_to_params(locals())
         if "path" in params:
+            if "type" not in params:
+                params["type"] = determine_screenshot_type(params["path"])
             del params["path"]
-        encoded_binary = await self._channel.send("screenshot", params)
+        if "mask" in params:
+            params["mask"] = list(
+                map(
+                    lambda locator: (
+                        {
+                            "frame": locator._frame._channel,
+                            "selector": locator._selector,
+                        }
+                    ),
+                    params["mask"],
+                )
+            )
+        encoded_binary = await self._channel.send(
+            "screenshot", self._timeout_settings.timeout, params
+        )
         decoded_binary = base64.b64decode(encoded_binary)
         if path:
-            with open(path, "wb") as fd:
-                fd.write(decoded_binary)
+            make_dirs_for_file(path)
+            await async_writefile(path, decoded_binary)
         return decoded_binary
 
     async def title(self) -> str:
         return await self._main_frame.title()
 
-    async def close(self, runBeforeUnload: bool = None) -> None:
+    async def aria_snapshot(
+        self,
+        timeout: float = None,
+        depth: int = None,
+        mode: Literal["ai", "default"] = None,
+        boxes: bool = None,
+    ) -> str:
+        return await self._main_frame._channel.send(
+            "ariaSnapshot",
+            self._main_frame._timeout,
+            locals_to_params(locals()),
+        )
+
+    async def close(self, runBeforeUnload: bool = None, reason: str = None) -> None:
+        self._close_reason = reason
+        self._close_was_called = True
         try:
-            await self._channel.send("close", locals_to_params(locals()))
+            await self._channel.send("close", None, locals_to_params(locals()))
             if self._owned_context:
                 await self._owned_context.close()
         except Exception as e:
-            if not is_safe_close_error(e):
+            if not is_target_closed_error(e) and not runBeforeUnload:
                 raise e
 
-    def isClosed(self) -> bool:
+    def is_closed(self) -> bool:
         return self._is_closed
 
     async def click(
         self,
         selector: str,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        delay: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
         button: MouseButton = None,
         clickCount: int = None,
-        timeout: int = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        trial: bool = None,
+        strict: bool = None,
     ) -> None:
-        return await self._main_frame.click(**locals_to_params(locals()))
+        return await self._main_frame._click(**locals_to_params(locals()))
 
     async def dblclick(
         self,
         selector: str,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        delay: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        delay: float = None,
         button: MouseButton = None,
-        timeout: int = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
     ) -> None:
         return await self._main_frame.dblclick(**locals_to_params(locals()))
 
     async def tap(
         self,
         selector: str,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        timeout: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
     ) -> None:
         return await self._main_frame.tap(**locals_to_params(locals()))
 
     async def fill(
-        self, selector: str, value: str, timeout: int = None, noWaitAfter: bool = None
+        self,
+        selector: str,
+        value: str,
+        timeout: float = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        force: bool = None,
     ) -> None:
         return await self._main_frame.fill(**locals_to_params(locals()))
 
-    async def focus(self, selector: str, timeout: int = None) -> None:
+    def locator(
+        self,
+        selector: str,
+        hasText: Union[str, Pattern[str]] = None,
+        hasNotText: Union[str, Pattern[str]] = None,
+        has: "Locator" = None,
+        hasNot: "Locator" = None,
+    ) -> "Locator":
+        return self._main_frame.locator(
+            selector,
+            hasText=hasText,
+            hasNotText=hasNotText,
+            has=has,
+            hasNot=hasNot,
+        )
+
+    def get_by_alt_text(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self._main_frame.get_by_alt_text(text, exact=exact)
+
+    def get_by_label(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self._main_frame.get_by_label(text, exact=exact)
+
+    def get_by_placeholder(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self._main_frame.get_by_placeholder(text, exact=exact)
+
+    def get_by_role(
+        self,
+        role: AriaRole,
+        checked: bool = None,
+        disabled: bool = None,
+        expanded: bool = None,
+        includeHidden: bool = None,
+        level: int = None,
+        name: Union[str, Pattern[str]] = None,
+        pressed: bool = None,
+        selected: bool = None,
+        exact: bool = None,
+        description: Union[str, Pattern[str]] = None,
+    ) -> "Locator":
+        return self._main_frame.get_by_role(
+            role,
+            checked=checked,
+            disabled=disabled,
+            expanded=expanded,
+            includeHidden=includeHidden,
+            level=level,
+            name=name,
+            pressed=pressed,
+            selected=selected,
+            exact=exact,
+            description=description,
+        )
+
+    def get_by_test_id(self, testId: Union[str, Pattern[str]]) -> "Locator":
+        return self._main_frame.get_by_test_id(testId)
+
+    def get_by_text(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self._main_frame.get_by_text(text, exact=exact)
+
+    def get_by_title(
+        self, text: Union[str, Pattern[str]], exact: bool = None
+    ) -> "Locator":
+        return self._main_frame.get_by_title(text, exact=exact)
+
+    def frame_locator(self, selector: str) -> "FrameLocator":
+        return self.main_frame.frame_locator(selector)
+
+    async def focus(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> None:
         return await self._main_frame.focus(**locals_to_params(locals()))
 
-    async def textContent(self, selector: str, timeout: int = None) -> Optional[str]:
-        return await self._main_frame.textContent(**locals_to_params(locals()))
+    async def text_content(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> Optional[str]:
+        return await self._main_frame.text_content(**locals_to_params(locals()))
 
-    async def innerText(self, selector: str, timeout: int = None) -> str:
-        return await self._main_frame.innerText(**locals_to_params(locals()))
+    async def inner_text(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> str:
+        return await self._main_frame.inner_text(**locals_to_params(locals()))
 
-    async def innerHTML(self, selector: str, timeout: int = None) -> str:
-        return await self._main_frame.innerHTML(**locals_to_params(locals()))
+    async def inner_html(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> str:
+        return await self._main_frame.inner_html(**locals_to_params(locals()))
 
-    async def getAttribute(
-        self, selector: str, name: str, timeout: int = None
+    async def get_attribute(
+        self, selector: str, name: str, strict: bool = None, timeout: float = None
     ) -> Optional[str]:
-        return await self._main_frame.getAttribute(**locals_to_params(locals()))
+        return await self._main_frame.get_attribute(**locals_to_params(locals()))
 
     async def hover(
         self,
         selector: str,
-        modifiers: List[KeyboardModifier] = None,
-        position: Tuple[float, float] = None,
-        timeout: int = None,
+        modifiers: Sequence[KeyboardModifier] = None,
+        position: Position = None,
+        timeout: float = None,
+        noWaitAfter: bool = None,
         force: bool = None,
+        strict: bool = None,
+        trial: bool = None,
     ) -> None:
         return await self._main_frame.hover(**locals_to_params(locals()))
 
-    async def selectOption(
+    async def drag_and_drop(
+        self,
+        source: str,
+        target: str,
+        sourcePosition: Position = None,
+        targetPosition: Position = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        timeout: float = None,
+        strict: bool = None,
+        trial: bool = None,
+        steps: int = None,
+    ) -> None:
+        return await self._main_frame.drag_and_drop(**locals_to_params(locals()))
+
+    async def select_option(
         self,
         selector: str,
-        value: Union[str, List[str]] = None,
-        index: Union[int, List[int]] = None,
-        label: Union[str, List[str]] = None,
-        element: Union["ElementHandle", List["ElementHandle"]] = None,
-        timeout: int = None,
+        value: Union[str, Sequence[str]] = None,
+        index: Union[int, Sequence[int]] = None,
+        label: Union[str, Sequence[str]] = None,
+        element: Union["ElementHandle", Sequence["ElementHandle"]] = None,
+        timeout: float = None,
         noWaitAfter: bool = None,
+        force: bool = None,
+        strict: bool = None,
     ) -> List[str]:
         params = locals_to_params(locals())
-        return await self._main_frame.selectOption(**params)
+        return await self._main_frame.select_option(**params)
+
+    async def input_value(
+        self, selector: str, strict: bool = None, timeout: float = None
+    ) -> str:
+        params = locals_to_params(locals())
+        return await self._main_frame.input_value(**params)
 
-    async def setInputFiles(
+    async def set_input_files(
         self,
         selector: str,
-        files: Union[str, FilePayload, List[str], List[FilePayload]],
-        timeout: int = None,
+        files: Union[
+            str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
+        ],
+        timeout: float = None,
+        strict: bool = None,
         noWaitAfter: bool = None,
     ) -> None:
-        return await self._main_frame.setInputFiles(**locals_to_params(locals()))
+        return await self._main_frame.set_input_files(**locals_to_params(locals()))
 
     async def type(
         self,
         selector: str,
         text: str,
-        delay: int = None,
-        timeout: int = None,
+        delay: float = None,
+        timeout: float = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
     ) -> None:
         return await self._main_frame.type(**locals_to_params(locals()))
 
@@ -754,52 +1092,83 @@ async def press(
         self,
         selector: str,
         key: str,
-        delay: int = None,
-        timeout: int = None,
+        delay: float = None,
+        timeout: float = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
     ) -> None:
         return await self._main_frame.press(**locals_to_params(locals()))
 
     async def check(
         self,
         selector: str,
-        timeout: int = None,
+        position: Position = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
     ) -> None:
         return await self._main_frame.check(**locals_to_params(locals()))
 
     async def uncheck(
         self,
         selector: str,
-        timeout: int = None,
+        position: Position = None,
+        timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
     ) -> None:
         return await self._main_frame.uncheck(**locals_to_params(locals()))
 
-    async def waitForTimeout(self, timeout: int) -> None:
-        await self._main_frame.waitForTimeout(timeout)
+    async def wait_for_timeout(self, timeout: float) -> None:
+        await self._main_frame.wait_for_timeout(timeout)
 
-    async def waitForFunction(
+    async def wait_for_function(
         self,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
-        timeout: int = None,
-        polling: Union[int, Literal["raf"]] = None,
+        timeout: float = None,
+        polling: Union[float, Literal["raf"]] = None,
     ) -> JSHandle:
-        if not is_function_body(expression):
-            force_expr = True
-        return await self._main_frame.waitForFunction(**locals_to_params(locals()))
+        return await self._main_frame.wait_for_function(**locals_to_params(locals()))
 
     @property
     def workers(self) -> List["Worker"]:
         return self._workers.copy()
 
+    @property
+    def request(self) -> "APIRequestContext":
+        return self.context.request
+
+    async def pause(self) -> None:
+        default_navigation_timeout = (
+            self._browser_context._timeout_settings.default_navigation_timeout()
+        )
+        default_timeout = self._browser_context._timeout_settings.default_timeout()
+        self._browser_context.set_default_navigation_timeout(0)
+        self._browser_context.set_default_timeout(0)
+        try:
+            await asyncio.wait(
+                [
+                    asyncio.create_task(
+                        self._browser_context._channel.send("pause", None)
+                    ),
+                    self._closed_or_crashed_future,
+                ],
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+        finally:
+            self._browser_context._set_default_navigation_timeout_impl(
+                default_navigation_timeout
+            )
+            self._browser_context._set_default_timeout_impl(default_timeout)
+
     async def pdf(
         self,
-        scale: int = None,
+        scale: float = None,
         displayHeaderFooter: bool = None,
         headerTemplate: str = None,
         footerTemplate: str = None,
@@ -812,127 +1181,332 @@ async def pdf(
         preferCSSPageSize: bool = None,
         margin: PdfMargins = None,
         path: Union[str, Path] = None,
+        outline: bool = None,
+        tagged: bool = None,
     ) -> bytes:
         params = locals_to_params(locals())
         if "path" in params:
             del params["path"]
-        encoded_binary = await self._channel.send("pdf", params)
+        encoded_binary = await self._channel.send("pdf", None, params)
         decoded_binary = base64.b64decode(encoded_binary)
         if path:
-            with open(path, "wb") as fd:
-                fd.write(decoded_binary)
+            make_dirs_for_file(path)
+            await async_writefile(path, decoded_binary)
         return decoded_binary
 
     @property
-    def video(
-        self,
-    ) -> Optional[Video]:
-        context_options = self._browser_context._options
-        if "recordVideo" not in context_options:
+    def video(self) -> Optional[Video]:
+        # Video is only exposed when the page actually produced a recording artifact.
+        # The initializer carries the artifact; if absent, no video was recorded.
+        if not self._video._artifact:
             return None
-        if not self._video:
-            self._video = Video(self)
-            if "videoRelativePath" in self._initializer:
-                self._video._set_relative_path(self._initializer["videoRelativePath"])
         return self._video
 
+    @property
+    def screencast(self) -> Screencast:
+        return self._screencast
+
+    def _close_error_with_reason(self) -> TargetClosedError:
+        return TargetClosedError(
+            self._close_reason or self._browser_context._effective_close_reason()
+        )
+
     def expect_event(
         self,
         event: str,
-        predicate: Callable[[Any], bool] = None,
-        timeout: int = None,
+        predicate: Callable = None,
+        timeout: float = None,
     ) -> EventContextManagerImpl:
-        return EventContextManagerImpl(self.waitForEvent(event, predicate, timeout))
+        return self._expect_event(
+            event, predicate, timeout, f'waiting for event "{event}"'
+        )
+
+    def _expect_event(
+        self,
+        event: str,
+        predicate: Callable = None,
+        timeout: float = None,
+        log_line: str = None,
+    ) -> EventContextManagerImpl:
+        if timeout is None:
+            timeout = self._timeout_settings.timeout()
+        waiter = Waiter(self, f"page.expect_event({event})")
+        waiter.reject_on_timeout(
+            timeout, f'Timeout {timeout}ms exceeded while waiting for event "{event}"'
+        )
+        if log_line:
+            waiter.log(log_line)
+        if event != Page.Events.Crash:
+            waiter.reject_on_event(self, Page.Events.Crash, Error("Page crashed"))
+        if event != Page.Events.Close:
+            waiter.reject_on_event(
+                self, Page.Events.Close, lambda: self._close_error_with_reason()
+            )
+        waiter.wait_for_event(self, event, predicate)
+        return EventContextManagerImpl(waiter.result())
 
     def expect_console_message(
         self,
         predicate: Callable[[ConsoleMessage], bool] = None,
-        timeout: int = None,
+        timeout: float = None,
     ) -> EventContextManagerImpl[ConsoleMessage]:
-        return EventContextManagerImpl(self.waitForEvent("console", predicate, timeout))
-
-    def expect_dialog(
-        self,
-        predicate: Callable[[Dialog], bool] = None,
-        timeout: int = None,
-    ) -> EventContextManagerImpl[Dialog]:
-        return EventContextManagerImpl(self.waitForEvent("dialog", predicate, timeout))
+        return self.expect_event(Page.Events.Console, predicate, timeout)
 
     def expect_download(
         self,
         predicate: Callable[[Download], bool] = None,
-        timeout: int = None,
+        timeout: float = None,
     ) -> EventContextManagerImpl[Download]:
-        return EventContextManagerImpl(
-            self.waitForEvent("download", predicate, timeout)
-        )
+        return self.expect_event(Page.Events.Download, predicate, timeout)
 
     def expect_file_chooser(
         self,
         predicate: Callable[[FileChooser], bool] = None,
-        timeout: int = None,
+        timeout: float = None,
     ) -> EventContextManagerImpl[FileChooser]:
-        return EventContextManagerImpl(
-            self.waitForEvent("filechooser", predicate, timeout)
-        )
-
-    def expect_load_state(
-        self,
-        state: DocumentLoadState = None,
-        timeout: int = None,
-    ) -> EventContextManagerImpl[Optional[Response]]:
-        return EventContextManagerImpl(self.waitForLoadState(state, timeout))
+        return self.expect_event(Page.Events.FileChooser, predicate, timeout)
 
     def expect_navigation(
         self,
         url: URLMatch = None,
         waitUntil: DocumentLoadState = None,
-        timeout: int = None,
-    ) -> EventContextManagerImpl[Optional[Response]]:
-        return EventContextManagerImpl(self.waitForNavigation(url, waitUntil, timeout))
+        timeout: float = None,
+    ) -> EventContextManagerImpl[Response]:
+        return self.main_frame.expect_navigation(url, waitUntil, timeout)
 
     def expect_popup(
         self,
         predicate: Callable[["Page"], bool] = None,
-        timeout: int = None,
+        timeout: float = None,
     ) -> EventContextManagerImpl["Page"]:
-        return EventContextManagerImpl(self.waitForEvent("popup", predicate, timeout))
+        return self.expect_event(Page.Events.Popup, predicate, timeout)
 
     def expect_request(
         self,
-        url: URLMatch = None,
-        predicate: Callable[[Request], bool] = None,
-        timeout: int = None,
+        urlOrPredicate: URLMatchRequest,
+        timeout: float = None,
+    ) -> EventContextManagerImpl[Request]:
+        def my_predicate(request: Request) -> Union[bool, Awaitable[bool]]:
+            if not callable(urlOrPredicate):
+                return url_matches(
+                    self._browser_context._base_url,
+                    request.url,
+                    urlOrPredicate,
+                )
+            return urlOrPredicate(request)
+
+        trimmed_url = trim_url(urlOrPredicate)
+        log_line = f"waiting for request {trimmed_url}" if trimmed_url else None
+        return self._expect_event(
+            Page.Events.Request,
+            predicate=my_predicate,
+            timeout=timeout,
+            log_line=log_line,
+        )
+
+    def expect_request_finished(
+        self,
+        predicate: Callable[["Request"], bool] = None,
+        timeout: float = None,
     ) -> EventContextManagerImpl[Request]:
-        return EventContextManagerImpl(self.waitForRequest(url, predicate, timeout))
+        return self.expect_event(
+            Page.Events.RequestFinished, predicate=predicate, timeout=timeout
+        )
 
     def expect_response(
         self,
-        url: URLMatch = None,
-        predicate: Callable[[Request], bool] = None,
-        timeout: int = None,
+        urlOrPredicate: URLMatchResponse,
+        timeout: float = None,
     ) -> EventContextManagerImpl[Response]:
-        return EventContextManagerImpl(self.waitForResponse(url, predicate, timeout))
+        def my_predicate(request: Response) -> Union[bool, Awaitable[bool]]:
+            if not callable(urlOrPredicate):
+                return url_matches(
+                    self._browser_context._base_url,
+                    request.url,
+                    urlOrPredicate,
+                )
+            return urlOrPredicate(request)
+
+        trimmed_url = trim_url(urlOrPredicate)
+        log_line = f"waiting for response {trimmed_url}" if trimmed_url else None
+        return self._expect_event(
+            Page.Events.Response,
+            predicate=my_predicate,
+            timeout=timeout,
+            log_line=log_line,
+        )
+
+    def expect_websocket(
+        self,
+        predicate: Callable[["WebSocket"], bool] = None,
+        timeout: float = None,
+    ) -> EventContextManagerImpl["WebSocket"]:
+        return self.expect_event("websocket", predicate, timeout)
 
     def expect_worker(
         self,
         predicate: Callable[["Worker"], bool] = None,
-        timeout: int = None,
+        timeout: float = None,
     ) -> EventContextManagerImpl["Worker"]:
-        return EventContextManagerImpl(self.waitForEvent("worker", predicate, timeout))
+        return self.expect_event("worker", predicate, timeout)
+
+    async def set_checked(
+        self,
+        selector: str,
+        checked: bool,
+        position: Position = None,
+        timeout: float = None,
+        force: bool = None,
+        noWaitAfter: bool = None,
+        strict: bool = None,
+        trial: bool = None,
+    ) -> None:
+        if checked:
+            await self.check(
+                selector=selector,
+                position=position,
+                timeout=timeout,
+                force=force,
+                strict=strict,
+                trial=trial,
+            )
+        else:
+            await self.uncheck(
+                selector=selector,
+                position=position,
+                timeout=timeout,
+                force=force,
+                strict=strict,
+                trial=trial,
+            )
+
+    async def add_locator_handler(
+        self,
+        locator: "Locator",
+        handler: Union[Callable[["Locator"], Any], Callable[[], Any]],
+        noWaitAfter: bool = None,
+        times: int = None,
+    ) -> None:
+        if locator._frame != self._main_frame:
+            raise Error("Locator must belong to the main frame of this page")
+        if times == 0:
+            return
+        uid = await self._channel.send(
+            "registerLocatorHandler",
+            None,
+            {
+                "selector": locator._selector,
+                "noWaitAfter": noWaitAfter,
+            },
+        )
+        self._locator_handlers[uid] = LocatorHandler(
+            handler=handler, times=times, locator=locator
+        )
+
+    async def _on_locator_handler_triggered(self, uid: str) -> None:
+        remove = False
+        try:
+            handler = self._locator_handlers.get(uid)
+            if handler and handler.times != 0:
+                if handler.times is not None:
+                    handler.times -= 1
+                if self._dispatcher_fiber:
+                    handler_finished_future = self._loop.create_future()
+
+                    def _handler() -> None:
+                        try:
+                            handler()
+                            handler_finished_future.set_result(None)
+                        except Exception as e:
+                            handler_finished_future.set_exception(e)
+
+                    g = LocatorHandlerGreenlet(_handler)
+                    g.switch()
+                    await handler_finished_future
+                else:
+                    coro_or_future = handler()
+                    if coro_or_future:
+                        await coro_or_future
+                remove = handler.times == 0
+        finally:
+            if remove:
+                del self._locator_handlers[uid]
+            try:
+                await self._connection.wrap_api_call(
+                    lambda: self._channel.send(
+                        "resolveLocatorHandlerNoReply",
+                        None,
+                        {"uid": uid, "remove": remove},
+                    ),
+                    is_internal=True,
+                )
+            except Error:
+                pass
+
+    async def remove_locator_handler(self, locator: "Locator") -> None:
+        for uid, data in self._locator_handlers.copy().items():
+            if data.locator._equals(locator):
+                del self._locator_handlers[uid]
+                self._channel.send_no_reply(
+                    "unregisterLocatorHandler",
+                    None,
+                    {"uid": uid},
+                )
+
+    async def requests(self) -> List[Request]:
+        request_objects = await self._channel.send("requests", None)
+        return [from_channel(r) for r in request_objects]
+
+    async def console_messages(
+        self, filter: Literal["all", "since-navigation"] = None
+    ) -> List[ConsoleMessage]:
+        message_dicts = await self._channel.send(
+            "consoleMessages", None, locals_to_params(locals())
+        )
+        return [
+            ConsoleMessage(
+                {**event, "page": self._channel}, self._loop, self._dispatcher_fiber
+            )
+            for event in message_dicts
+        ]
+
+    async def page_errors(
+        self, filter: Literal["all", "since-navigation"] = None
+    ) -> List[Error]:
+        error_objects = await self._channel.send(
+            "pageErrors", None, locals_to_params(locals())
+        )
+        return [parse_error(error["error"]) for error in error_objects]
+
+    async def clear_console_messages(self) -> None:
+        await self._channel.send("clearConsoleMessages", None)
+
+    async def clear_page_errors(self) -> None:
+        await self._channel.send("clearPageErrors", None)
+
+    async def pick_locator(self) -> "Locator":
+        selector = await self._channel.send("pickLocator", None, {})
+        return self.locator(selector)
+
+    async def cancel_pick_locator(self) -> None:
+        await self._channel.send("cancelPickLocator", None, {})
 
 
 class Worker(ChannelOwner):
-    Events = SimpleNamespace(Close="close")
+    Events = SimpleNamespace(Close="close", Console="console")
 
     def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        self._set_event_to_subscription_mapping({Worker.Events.Console: "console"})
         self._channel.on("close", lambda _: self._on_close())
         self._page: Optional[Page] = None
         self._context: Optional["BrowserContext"] = None
 
+    def __repr__(self) -> str:
+        return f"<Worker url={self.url!r}>"
+
     def _on_close(self) -> None:
         if self._page:
             self._page._workers.remove(self)
@@ -944,36 +1518,57 @@ def _on_close(self) -> None:
     def url(self) -> str:
         return self._initializer["url"]
 
-    async def evaluate(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
-    ) -> Any:
-        if not is_function_body(expression):
-            force_expr = True
+    async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
         return parse_result(
             await self._channel.send(
                 "evaluateExpression",
+                None,
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
-    async def evaluateHandle(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
+    async def evaluate_handle(
+        self, expression: str, arg: Serializable = None
     ) -> JSHandle:
         return from_channel(
             await self._channel.send(
                 "evaluateExpressionHandle",
+                None,
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
+    def expect_event(
+        self,
+        event: str,
+        predicate: Callable = None,
+        timeout: float = None,
+    ) -> EventContextManagerImpl:
+        if timeout is None:
+            if self._page:
+                timeout = self._page._timeout_settings.timeout()
+            elif self._context:
+                timeout = self._context._timeout_settings.timeout()
+            else:
+                timeout = 30000
+        waiter = Waiter(self, f"worker.expect_event({event})")
+        waiter.reject_on_timeout(
+            cast(float, timeout),
+            f'Timeout {timeout}ms exceeded while waiting for event "{event}"',
+        )
+        if event != Worker.Events.Close:
+            waiter.reject_on_event(
+                self, Worker.Events.Close, lambda: TargetClosedError()
+            )
+        waiter.wait_for_event(self, event, predicate)
+        return EventContextManagerImpl(waiter.result())
+
 
 class BindingCall(ChannelOwner):
     def __init__(
@@ -990,11 +1585,29 @@ async def call(self, func: Callable) -> None:
             else:
                 func_args = list(map(parse_result, self._initializer["args"]))
                 result = func(source, *func_args)
-            if asyncio.isfuture(result):
+            if inspect.iscoroutine(result):
                 result = await result
-            await self._channel.send("resolve", dict(result=serialize_argument(result)))
+            await self._channel.send(
+                "resolve", None, dict(result=serialize_argument(result))
+            )
         except Exception as e:
             tb = sys.exc_info()[2]
             asyncio.create_task(
-                self._channel.send("reject", dict(error=serialize_error(e, tb)))
+                self._channel.send(
+                    "reject", None, dict(error=dict(error=serialize_error(e, tb)))
+                )
             )
+
+
+def trim_url(param: Union[URLMatchRequest, URLMatchResponse]) -> Optional[str]:
+    if isinstance(param, re.Pattern):
+        return trim_end(param.pattern)
+    if isinstance(param, str):
+        return trim_end(param)
+    return None
+
+
+def trim_end(s: str) -> str:
+    if len(s) > 50:
+        return s[:50] + "\u2026"
+    return s
diff --git a/playwright/_impl/_path_utils.py b/playwright/_impl/_path_utils.py
index 8be1e79ec..b405a0675 100644
--- a/playwright/_impl/_path_utils.py
+++ b/playwright/_impl/_path_utils.py
@@ -14,11 +14,14 @@
 
 import inspect
 from pathlib import Path
+from types import FrameType
+from typing import cast
 
 
 def get_file_dirname() -> Path:
     """Returns the callee (`__file__`) directory name"""
-    frame = inspect.stack()[1]
-    module = inspect.getmodule(frame[0])
+    frame = cast(FrameType, inspect.currentframe()).f_back
+    module = inspect.getmodule(frame)
     assert module
+    assert module.__file__
     return Path(module.__file__).parent.absolute()
diff --git a/playwright/_impl/_playwright.py b/playwright/_impl/_playwright.py
index af3c3f463..5c0151158 100644
--- a/playwright/_impl/_playwright.py
+++ b/playwright/_impl/_playwright.py
@@ -14,42 +14,47 @@
 
 from typing import Dict
 
-from playwright._impl._api_types import DeviceDescriptor
 from playwright._impl._browser_type import BrowserType
 from playwright._impl._connection import ChannelOwner, from_channel
+from playwright._impl._fetch import APIRequest
 from playwright._impl._selectors import Selectors
 
 
 class Playwright(ChannelOwner):
+    devices: Dict
+    selectors: Selectors
     chromium: BrowserType
     firefox: BrowserType
     webkit: BrowserType
-    selectors: Selectors
-    devices: Dict[str, DeviceDescriptor]
+    request: APIRequest
 
     def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        self.request = APIRequest(self)
         self.chromium = from_channel(initializer["chromium"])
+        self.chromium._playwright = self
         self.firefox = from_channel(initializer["firefox"])
+        self.firefox._playwright = self
         self.webkit = from_channel(initializer["webkit"])
-        self.selectors = from_channel(initializer["selectors"])
-        self.devices = {}
-        self.devices = {
-            device["name"]: parse_device_descriptor(device["descriptor"])
-            for device in initializer["deviceDescriptors"]
-        }
-
-    def stop(self) -> None:
-        pass
+        self.webkit._playwright = self
+
+        self.selectors = Selectors(self._loop, self._dispatcher_fiber)
 
+        self.devices = self._connection.local_utils.devices
 
-def parse_device_descriptor(dict: Dict) -> DeviceDescriptor:
-    return {
-        "user_agent": dict["userAgent"],
-        "viewport": dict["viewport"],
-        "device_scale_factor": dict["deviceScaleFactor"],
-        "is_mobile": dict["isMobile"],
-        "has_touch": dict["hasTouch"],
-    }
+    def __getitem__(self, value: str) -> "BrowserType":
+        if value == "chromium":
+            return self.chromium
+        elif value == "firefox":
+            return self.firefox
+        elif value == "webkit":
+            return self.webkit
+        raise ValueError("Invalid browser " + value)
+
+    def _set_selectors(self, selectors: Selectors) -> None:
+        self.selectors = selectors
+
+    async def stop(self) -> None:
+        pass
diff --git a/playwright/_impl/_screencast.py b/playwright/_impl/_screencast.py
new file mode 100644
index 000000000..600297203
--- /dev/null
+++ b/playwright/_impl/_screencast.py
@@ -0,0 +1,146 @@
+# 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 base64
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, Union
+
+from playwright._impl._api_structures import ScreencastFrame
+from playwright._impl._artifact import Artifact
+from playwright._impl._connection import from_nullable_channel
+from playwright._impl._disposable import DisposableStub
+from playwright._impl._errors import Error
+from playwright._impl._helper import locals_to_params
+
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._page import Page
+
+
+ScreencastFrameCallback = Callable[[ScreencastFrame], Any]
+ScreencastPosition = Literal[
+    "bottom",
+    "bottom-left",
+    "bottom-right",
+    "top",
+    "top-left",
+    "top-right",
+]
+
+
+class Screencast:
+    def __init__(self, page: "Page") -> None:
+        self._page = page
+        self._loop = page._loop
+        self._dispatcher_fiber = page._dispatcher_fiber
+        self._started = False
+        self._save_path: Optional[Union[str, Path]] = None
+        self._on_frame: Optional[ScreencastFrameCallback] = None
+        self._artifact: Optional[Artifact] = None
+        page._channel.on("screencastFrame", lambda params: self._dispatch_frame(params))
+
+    def _dispatch_frame(self, params: dict) -> None:
+        if not self._on_frame:
+            return
+        data = params["data"]
+        if isinstance(data, str):
+            data = base64.b64decode(data)
+        result = self._on_frame(
+            {
+                "data": data,
+                "viewportWidth": params["viewportWidth"],
+                "viewportHeight": params["viewportHeight"],
+            }
+        )
+        if hasattr(result, "__await__"):
+            self._page._loop.create_task(result)
+
+    async def start(
+        self,
+        onFrame: ScreencastFrameCallback = None,
+        path: Union[str, Path] = None,
+        quality: int = None,
+    ) -> DisposableStub:
+        if self._started:
+            raise Error("Screencast is already started")
+        self._started = True
+        self._on_frame = onFrame
+        result = await self._page._channel.send_return_as_dict(
+            "screencastStart",
+            None,
+            {
+                "quality": quality,
+                "sendFrames": bool(onFrame),
+                "record": bool(path),
+            },
+        )
+        artifact_channel = (result or {}).get("artifact")
+        if artifact_channel:
+            self._artifact = from_nullable_channel(artifact_channel)
+            self._save_path = path
+        return DisposableStub(lambda: self.stop(), self._page)
+
+    async def stop(self) -> None:
+        self._started = False
+        self._on_frame = None
+        await self._page._channel.send("screencastStop", None)
+        if self._save_path and self._artifact:
+            await self._artifact.save_as(self._save_path)
+        self._artifact = None
+        self._save_path = None
+
+    async def show_actions(
+        self,
+        duration: float = None,
+        position: ScreencastPosition = None,
+        fontSize: int = None,
+    ) -> DisposableStub:
+        await self._page._channel.send(
+            "screencastShowActions", None, locals_to_params(locals())
+        )
+        return DisposableStub(lambda: self.hide_actions(), self._page)
+
+    async def hide_actions(self) -> None:
+        await self._page._channel.send("screencastHideActions", None)
+
+    async def show_overlay(self, html: str, duration: float = None) -> DisposableStub:
+        result = await self._page._channel.send_return_as_dict(
+            "screencastShowOverlay", None, locals_to_params(locals())
+        )
+        overlay_id = (result or {}).get("id")
+        return DisposableStub(
+            lambda: self._page._channel.send(
+                "screencastRemoveOverlay", None, {"id": overlay_id}
+            ),
+            self._page,
+        )
+
+    async def show_chapter(
+        self,
+        title: str,
+        description: str = None,
+        duration: float = None,
+    ) -> None:
+        await self._page._channel.send(
+            "screencastChapter", None, locals_to_params(locals())
+        )
+
+    async def show_overlays(self) -> None:
+        await self._page._channel.send(
+            "screencastSetOverlayVisible", None, {"visible": True}
+        )
+
+    async def hide_overlays(self) -> None:
+        await self._page._channel.send(
+            "screencastSetOverlayVisible", None, {"visible": False}
+        )
diff --git a/playwright/_impl/_selectors.py b/playwright/_impl/_selectors.py
index 19be17cbc..c3bac78e5 100644
--- a/playwright/_impl/_selectors.py
+++ b/playwright/_impl/_selectors.py
@@ -12,32 +12,56 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
 from pathlib import Path
-from typing import Dict, Union
+from typing import Any, Dict, List, Optional, Set, Union
 
-from playwright._impl._api_types import Error
-from playwright._impl._connection import ChannelOwner
+from playwright._impl._browser_context import BrowserContext
+from playwright._impl._errors import Error
+from playwright._impl._helper import async_readfile
+from playwright._impl._locator import set_test_id_attribute_name
 
 
-class Selectors(ChannelOwner):
-    def __init__(
-        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
-    ) -> None:
-        super().__init__(parent, type, guid, initializer)
+class Selectors:
+    def __init__(self, loop: asyncio.AbstractEventLoop, dispatcher_fiber: Any) -> None:
+        self._loop = loop
+        self._contexts_for_selectors: Set[BrowserContext] = set()
+        self._selector_engines: List[Dict] = []
+        self._dispatcher_fiber = dispatcher_fiber
+        self._test_id_attribute_name: Optional[str] = None
 
     async def register(
         self,
         name: str,
-        source: str = None,
+        script: str = None,
         path: Union[str, Path] = None,
         contentScript: bool = None,
     ) -> None:
-        if not source and not path:
+        if any(engine for engine in self._selector_engines if engine["name"] == name):
+            raise Error(
+                f'Selectors.register: "{name}" selector engine has been already registered'
+            )
+        if not script and not path:
             raise Error("Either source or path should be specified")
         if path:
-            with open(path, "r") as file:
-                source = file.read()
-        params: Dict = dict(name=name, source=source)
+            script = (await async_readfile(path)).decode()
+        engine: Dict[str, Any] = dict(name=name, source=script)
         if contentScript:
-            params["contentScript"] = True
-        await self._channel.send("register", params)
+            engine["contentScript"] = contentScript
+        for context in self._contexts_for_selectors:
+            await context._channel.send(
+                "registerSelectorEngine",
+                None,
+                {"selectorEngine": engine},
+            )
+        self._selector_engines.append(engine)
+
+    def set_test_id_attribute(self, attributeName: str) -> None:
+        set_test_id_attribute_name(attributeName)
+        self._test_id_attribute_name = attributeName
+        for context in self._contexts_for_selectors:
+            context._channel.send_no_reply(
+                "setTestIdAttributeName",
+                None,
+                {"testIdAttributeName": attributeName},
+            )
diff --git a/playwright/_impl/_set_input_files_helpers.py b/playwright/_impl/_set_input_files_helpers.py
new file mode 100644
index 000000000..65307e0a2
--- /dev/null
+++ b/playwright/_impl/_set_input_files_helpers.py
@@ -0,0 +1,158 @@
+# 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 base64
+import collections.abc
+import os
+import stat
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    TypedDict,
+    Union,
+    cast,
+)
+
+from playwright._impl._connection import Channel, from_channel
+from playwright._impl._helper import Error
+from playwright._impl._writable_stream import WritableStream
+
+if TYPE_CHECKING:  # pragma: no cover
+    from playwright._impl._browser_context import BrowserContext
+
+from playwright._impl._api_structures import FilePayload
+
+SIZE_LIMIT_IN_BYTES = 50 * 1024 * 1024
+
+
+class InputFilesList(TypedDict, total=False):
+    streams: Optional[List[Channel]]
+    directoryStream: Optional[Channel]
+    localDirectory: Optional[str]
+    localPaths: Optional[List[str]]
+    payloads: Optional[List[Dict[str, Union[str, bytes]]]]
+
+
+def _list_files(directory: str) -> List[str]:
+    files = []
+    for root, _, filenames in os.walk(directory):
+        for filename in filenames:
+            files.append(os.path.join(root, filename))
+    return files
+
+
+async def convert_input_files(
+    files: Union[
+        str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
+    ],
+    context: "BrowserContext",
+) -> InputFilesList:
+    items = (
+        files
+        if isinstance(files, collections.abc.Sequence) and not isinstance(files, str)
+        else [files]
+    )
+
+    if any([isinstance(item, (str, Path)) for item in items]):
+        if not all([isinstance(item, (str, Path)) for item in items]):
+            raise Error("File paths cannot be mixed with buffers")
+
+        (local_paths, local_directory) = resolve_paths_and_directory_for_input_files(
+            cast(Sequence[Union[str, Path]], items)
+        )
+
+        if context._channel._connection.is_remote:
+            files_to_stream = cast(
+                List[str],
+                (_list_files(local_directory) if local_directory else local_paths),
+            )
+            streams = []
+            result = await context._connection.wrap_api_call(
+                lambda: context._channel.send_return_as_dict(
+                    "createTempFiles",
+                    None,
+                    {
+                        "rootDirName": (
+                            os.path.basename(local_directory)
+                            if local_directory
+                            else None
+                        ),
+                        "items": list(
+                            map(
+                                lambda file: dict(
+                                    name=(
+                                        os.path.relpath(file, local_directory)
+                                        if local_directory
+                                        else os.path.basename(file)
+                                    ),
+                                    lastModifiedMs=int(os.path.getmtime(file) * 1000),
+                                ),
+                                files_to_stream,
+                            )
+                        ),
+                    },
+                )
+            )
+            for i, file in enumerate(result["writableStreams"]):
+                stream: WritableStream = from_channel(file)
+                await stream.copy(files_to_stream[i])
+                streams.append(stream._channel)
+            return InputFilesList(
+                streams=None if local_directory else streams,
+                directoryStream=result.get("rootDir"),
+            )
+        return InputFilesList(localPaths=local_paths, localDirectory=local_directory)
+
+    file_payload_exceeds_size_limit = (
+        sum([len(f.get("buffer", "")) for f in items if not isinstance(f, (str, Path))])
+        > SIZE_LIMIT_IN_BYTES
+    )
+    if file_payload_exceeds_size_limit:
+        raise Error(
+            "Cannot set buffer larger than 50Mb, please write it to a file and pass its path instead."
+        )
+
+    return InputFilesList(
+        payloads=[
+            {
+                "name": item["name"],
+                "mimeType": item["mimeType"],
+                "buffer": base64.b64encode(item["buffer"]).decode(),
+            }
+            for item in cast(List[FilePayload], items)
+        ]
+    )
+
+
+def resolve_paths_and_directory_for_input_files(
+    items: Sequence[Union[str, Path]],
+) -> Tuple[Optional[List[str]], Optional[str]]:
+    local_paths: Optional[List[str]] = None
+    local_directory: Optional[str] = None
+    for item in items:
+        item_stat = os.stat(item)  # Raises FileNotFoundError if doesn't exist
+        if stat.S_ISDIR(item_stat.st_mode):
+            if local_directory:
+                raise Error("Multiple directories are not supported")
+            local_directory = str(Path(item).resolve())
+        else:
+            local_paths = local_paths or []
+            local_paths.append(str(Path(item).resolve()))
+    if local_paths and local_directory:
+        raise Error("File paths must be all files or a single directory")
+    return (local_paths, local_directory)
diff --git a/playwright/_impl/_str_utils.py b/playwright/_impl/_str_utils.py
new file mode 100644
index 000000000..8b3e65a39
--- /dev/null
+++ b/playwright/_impl/_str_utils.py
@@ -0,0 +1,76 @@
+# 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 json
+import re
+from typing import Pattern, Union
+
+
+def escape_regex_flags(pattern: Pattern) -> str:
+    flags = ""
+    if pattern.flags != 0:
+        flags = ""
+    if (pattern.flags & int(re.IGNORECASE)) != 0:
+        flags += "i"
+    if (pattern.flags & int(re.DOTALL)) != 0:
+        flags += "s"
+    if (pattern.flags & int(re.MULTILINE)) != 0:
+        flags += "m"
+    assert (
+        pattern.flags
+        & ~(int(re.MULTILINE) | int(re.IGNORECASE) | int(re.DOTALL) | int(re.UNICODE))
+        == 0
+    ), "Unexpected re.Pattern flag, only MULTILINE, IGNORECASE and DOTALL are supported."
+    return flags
+
+
+def escape_for_regex(text: str) -> str:
+    return re.sub(r"[.*+?^>${}()|[\]\\]", "\\$&", text)
+
+
+def escape_regex_for_selector(text: Pattern) -> str:
+    # Even number of backslashes followed by the quote -> insert a backslash.
+    return (
+        "/"
+        + re.sub(r'(^|[^\\])(\\\\)*(["\'`])', r"\1\2\\\3", text.pattern).replace(
+            ">>", "\\>\\>"
+        )
+        + "/"
+        + escape_regex_flags(text)
+    )
+
+
+def escape_for_text_selector(
+    text: Union[str, Pattern[str]], exact: bool = None, case_sensitive: bool = None
+) -> str:
+    if isinstance(text, Pattern):
+        return escape_regex_for_selector(text)
+    return json.dumps(text) + ("s" if exact else "i")
+
+
+def escape_for_attribute_selector(
+    value: Union[str, Pattern], exact: bool = None
+) -> str:
+    if isinstance(value, Pattern):
+        return escape_regex_for_selector(value)
+    # TODO: this should actually be
+    #   cssEscape(value).replace(/\\ /g, ' ')
+    # However, our attribute selectors do not conform to CSS parsing spec,
+    # so we escape them differently.
+    return (
+        '"'
+        + value.replace("\\", "\\\\").replace('"', '\\"')
+        + '"'
+        + ("s" if exact else "i")
+    )
diff --git a/playwright/_impl/_stream.py b/playwright/_impl/_stream.py
new file mode 100644
index 000000000..04afa48e1
--- /dev/null
+++ b/playwright/_impl/_stream.py
@@ -0,0 +1,46 @@
+# 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 base64
+from pathlib import Path
+from typing import Dict, Union
+
+from playwright._impl._connection import ChannelOwner
+
+
+class Stream(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+
+    async def save_as(self, path: Union[str, Path]) -> None:
+        file = await self._loop.run_in_executor(None, lambda: open(path, "wb"))
+        while True:
+            binary = await self._channel.send("read", None, {"size": 1024 * 1024})
+            if not binary:
+                break
+            await self._loop.run_in_executor(
+                None, lambda: file.write(base64.b64decode(binary))
+            )
+        await self._loop.run_in_executor(None, lambda: file.close())
+
+    async def read_all(self) -> bytes:
+        binary = b""
+        while True:
+            chunk = await self._channel.send("read", None, {"size": 1024 * 1024})
+            if not chunk:
+                break
+            binary += base64.b64decode(chunk)
+        return binary
diff --git a/playwright/_impl/_sync_base.py b/playwright/_impl/_sync_base.py
index 77912718b..3fef433b5 100644
--- a/playwright/_impl/_sync_base.py
+++ b/playwright/_impl/_sync_base.py
@@ -13,136 +13,139 @@
 # limitations under the License.
 
 import asyncio
+import inspect
+import traceback
+from contextlib import AbstractContextManager
+from types import TracebackType
 from typing import (
     Any,
     Callable,
     Coroutine,
-    Dict,
+    Generator,
     Generic,
-    List,
     Optional,
+    Type,
     TypeVar,
+    Union,
     cast,
 )
 
 import greenlet
 
+from playwright._impl._helper import Error
 from playwright._impl._impl_to_api_mapping import ImplToApiMapping, ImplWrapper
 
 mapping = ImplToApiMapping()
 
 
 T = TypeVar("T")
+Self = TypeVar("Self", bound="SyncContextManager")
 
 
 class EventInfo(Generic[T]):
-    def __init__(self, sync_base: "SyncBase", coroutine: Coroutine) -> None:
+    def __init__(self, sync_base: "SyncBase", future: "asyncio.Future[T]") -> None:
         self._sync_base = sync_base
-        self._value: Optional[T] = None
-        self._exception = None
-        self._future = sync_base._loop.create_task(coroutine)
+        self._future = future
         g_self = greenlet.getcurrent()
-
-        def done_callback(task: Any) -> None:
-            try:
-                self._value = mapping.from_maybe_impl(self._future.result())
-            except Exception as e:
-                self._exception = e
-            finally:
-                g_self.switch()
-
-        self._future.add_done_callback(done_callback)
+        self._future.add_done_callback(lambda _: g_self.switch())
 
     @property
     def value(self) -> T:
         while not self._future.done():
             self._sync_base._dispatcher_fiber.switch()
         asyncio._set_running_loop(self._sync_base._loop)
-        if self._exception:
-            raise self._exception
-        return cast(T, self._value)
+        exception = self._future.exception()
+        if exception:
+            raise exception
+        return cast(T, mapping.from_maybe_impl(self._future.result()))
+
+    def _cancel(self) -> None:
+        self._future.cancel()
+
+    def is_done(self) -> bool:
+        return self._future.done()
 
 
-class EventContextManager(Generic[T]):
-    def __init__(self, sync_base: "SyncBase", coroutine: Coroutine) -> None:
-        self._event: EventInfo = EventInfo(sync_base, coroutine)
+class EventContextManager(Generic[T], AbstractContextManager):
+    def __init__(self, sync_base: "SyncBase", future: "asyncio.Future[T]") -> None:
+        self._event = EventInfo[T](sync_base, future)
 
     def __enter__(self) -> EventInfo[T]:
         return self._event
 
-    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        self._event.value
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        if exc_val:
+            self._event._cancel()
+        else:
+            self._event.value
 
 
 class SyncBase(ImplWrapper):
     def __init__(self, impl_obj: Any) -> None:
         super().__init__(impl_obj)
-        self._loop = impl_obj._loop
+        self._loop: asyncio.AbstractEventLoop = impl_obj._loop
         self._dispatcher_fiber = impl_obj._dispatcher_fiber
 
     def __str__(self) -> str:
         return self._impl_obj.__str__()
 
-    def _sync(self, task: asyncio.Future) -> Any:
-        g_self = greenlet.getcurrent()
-        future = self._loop.create_task(task)
+    def _sync(
+        self,
+        coro: Union[Coroutine[Any, Any, Any], Generator[Any, Any, Any]],
+    ) -> Any:
+        __tracebackhide__ = True
+        if self._loop.is_closed():
+            coro.close()
+            raise Error("Event loop is closed! Is Playwright already stopped?")
 
-        def callback(result: Any) -> None:
-            g_self.switch()
+        g_self = greenlet.getcurrent()
+        task: asyncio.tasks.Task[Any] = self._loop.create_task(coro)
+        setattr(task, "__pw_stack__", inspect.stack(0))
+        setattr(task, "__pw_stack_trace__", traceback.extract_stack(limit=10))
 
-        future.add_done_callback(callback)
-        while not future.done():
+        task.add_done_callback(lambda _: g_self.switch())
+        while not task.done():
             self._dispatcher_fiber.switch()
         asyncio._set_running_loop(self._loop)
-        return future.result()
+        return task.result()
 
-    def _wrap_handler(self, handler: Any) -> Callable[..., None]:
+    def _wrap_handler(
+        self, handler: Union[Callable[..., Any], Any]
+    ) -> Callable[..., None]:
         if callable(handler):
             return mapping.wrap_handler(handler)
         return handler
 
-    def on(self, event: str, f: Any) -> None:
+    def on(self, event: Any, f: Any) -> None:
         """Registers the function ``f`` to the event name ``event``."""
         self._impl_obj.on(event, self._wrap_handler(f))
 
-    def once(self, event: str, f: Any) -> None:
+    def once(self, event: Any, f: Any) -> None:
         """The same as ``self.on``, except that the listener is automatically
         removed after being called.
         """
         self._impl_obj.once(event, self._wrap_handler(f))
 
-    def remove_listener(self, event: str, f: Any) -> None:
+    def remove_listener(self, event: Any, f: Any) -> None:
         """Removes the function ``f`` from ``event``."""
         self._impl_obj.remove_listener(event, self._wrap_handler(f))
 
-    def _gather(self, *actions: Callable) -> List[Any]:
-        g_self = greenlet.getcurrent()
-        results: Dict[Callable, Any] = {}
-        exceptions: List[Exception] = []
 
-        def action_wrapper(action: Callable) -> Callable:
-            def body() -> Any:
-                try:
-                    results[action] = action()
-                except Exception as e:
-                    results[action] = e
-                    exceptions.append(e)
-                g_self.switch()
+class SyncContextManager(SyncBase):
+    def __enter__(self: Self) -> Self:
+        return self
 
-            return body
-
-        async def task() -> None:
-            for action in actions:
-                g = greenlet.greenlet(action_wrapper(action))
-                g.switch()
-
-        self._loop.create_task(task())
-
-        while len(results) < len(actions):
-            self._dispatcher_fiber.switch()
-
-        asyncio._set_running_loop(self._loop)
-        if exceptions:
-            raise exceptions[0]
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        _traceback: Optional[TracebackType],
+    ) -> None:
+        self.close()
 
-        return list(map(lambda action: results[action], actions))
+    def close(self) -> None: ...
diff --git a/playwright/_impl/_tracing.py b/playwright/_impl/_tracing.py
new file mode 100644
index 000000000..be79deef1
--- /dev/null
+++ b/playwright/_impl/_tracing.py
@@ -0,0 +1,281 @@
+# 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 pathlib
+from typing import Any, Dict, Literal, Optional, Pattern, Union, cast
+
+from playwright._impl._api_structures import TracingGroupLocation
+from playwright._impl._artifact import Artifact
+from playwright._impl._connection import (
+    ChannelOwner,
+    from_channel,
+    from_nullable_channel,
+)
+from playwright._impl._disposable import DisposableStub
+from playwright._impl._helper import Error, locals_to_params
+
+
+class Tracing(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._include_sources: bool = False
+        self._is_live: bool = False
+        self._stacks_id: Optional[str] = None
+        self._is_tracing: bool = False
+        self._traces_dir: Optional[str] = None
+        self._har_id: Optional[str] = None
+        self._har_recorders: Dict[str, Dict[str, str]] = {}
+
+    async def start(
+        self,
+        name: str = None,
+        title: str = None,
+        snapshots: bool = None,
+        screenshots: bool = None,
+        sources: bool = None,
+        live: bool = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        self._include_sources = bool(sources)
+        self._is_live = bool(live)
+
+        await self._channel.send(
+            "tracingStart",
+            None,
+            {
+                "name": name,
+                "snapshots": snapshots,
+                "screenshots": screenshots,
+                "live": live,
+            },
+        )
+        trace_name = await self._channel.send(
+            "tracingStartChunk", None, {"title": title, "name": name}
+        )
+        await self._start_collecting_stacks(trace_name)
+
+    async def start_chunk(self, title: str = None, name: str = None) -> None:
+        params = locals_to_params(locals())
+        trace_name = await self._channel.send("tracingStartChunk", None, params)
+        await self._start_collecting_stacks(trace_name)
+
+    async def _start_collecting_stacks(self, trace_name: str) -> None:
+        if not self._is_tracing:
+            self._is_tracing = True
+            self._connection.set_is_tracing(True)
+        self._stacks_id = await self._connection.local_utils.tracing_started(
+            self._traces_dir, trace_name, self._is_live
+        )
+
+    async def stop_chunk(self, path: Union[pathlib.Path, str] = None) -> None:
+        await self._do_stop_chunk(path)
+
+    async def stop(self, path: Union[pathlib.Path, str] = None) -> None:
+        await self._do_stop_chunk(path)
+        await self._channel.send(
+            "tracingStop",
+            None,
+        )
+
+    async def _do_stop_chunk(self, file_path: Union[pathlib.Path, str] = None) -> None:
+        self._reset_stack_counter()
+
+        if not file_path:
+            # Not interested in any artifacts
+            await self._channel.send("tracingStopChunk", None, {"mode": "discard"})
+            if self._stacks_id:
+                await self._connection.local_utils.trace_discarded(self._stacks_id)
+            return
+
+        is_local = not self._connection.is_remote
+
+        if is_local:
+            result = await self._channel.send_return_as_dict(
+                "tracingStopChunk", None, {"mode": "entries"}
+            )
+            await self._connection.local_utils.zip(
+                {
+                    "zipFile": str(file_path),
+                    "entries": result["entries"],
+                    "stacksId": self._stacks_id,
+                    "mode": "write",
+                    "includeSources": self._include_sources,
+                }
+            )
+            return
+
+        result = await self._channel.send_return_as_dict(
+            "tracingStopChunk",
+            None,
+            {
+                "mode": "archive",
+            },
+        )
+
+        artifact = cast(
+            Optional[Artifact],
+            from_nullable_channel(result.get("artifact")),
+        )
+
+        # The artifact may be missing if the browser closed while stopping tracing.
+        if not artifact:
+            if self._stacks_id:
+                await self._connection.local_utils.trace_discarded(self._stacks_id)
+            return
+
+        # Save trace to the final local file.
+        await artifact.save_as(file_path)
+        await artifact.delete()
+
+        await self._connection.local_utils.zip(
+            {
+                "zipFile": str(file_path),
+                "entries": [],
+                "stacksId": self._stacks_id,
+                "mode": "append",
+                "includeSources": self._include_sources,
+            }
+        )
+
+    def _reset_stack_counter(self) -> None:
+        if self._is_tracing:
+            self._is_tracing = False
+            self._connection.set_is_tracing(False)
+
+    async def group(
+        self, name: str, location: TracingGroupLocation = None
+    ) -> DisposableStub:
+        await self._channel.send("tracingGroup", None, locals_to_params(locals()))
+        return DisposableStub(lambda: self.group_end(), self)
+
+    async def group_end(self) -> None:
+        await self._channel.send(
+            "tracingGroupEnd",
+            None,
+        )
+
+    async def start_har(
+        self,
+        path: Union[pathlib.Path, str],
+        content: Literal["attach", "embed", "omit"] = None,
+        mode: Literal["full", "minimal"] = None,
+        urlFilter: Union[str, Pattern[str]] = None,
+    ) -> DisposableStub:
+        if self._har_id:
+            raise Error("HAR recording has already been started")
+        is_zip = str(path).endswith(".zip")
+        default_content: Literal["attach", "embed", "omit"] = (
+            "attach" if is_zip else "embed"
+        )
+        self._har_id = await self._record_into_har(
+            har=path,
+            page=None,
+            url=urlFilter,
+            update_content=content or default_content,
+            update_mode=mode or "full",
+        )
+        return DisposableStub(lambda: self.stop_har(), self)
+
+    async def _record_into_har(
+        self,
+        har: Union[pathlib.Path, str],
+        page: Optional[ChannelOwner],
+        url: Union[str, Pattern[str]] = None,
+        update_content: Literal["attach", "embed", "omit"] = None,
+        update_mode: Literal["full", "minimal"] = None,
+        resourcesDir: Optional[str] = None,
+    ) -> str:
+        is_zip = str(har).endswith(".zip")
+        url_glob: Optional[str] = None
+        url_regex_source: Optional[str] = None
+        url_regex_flags: Optional[str] = None
+        if isinstance(url, str):
+            url_glob = url
+        elif url is not None:
+            url_regex_source = url.pattern
+            url_regex_flags = "".join(
+                flag
+                for flag, mask in (("i", 2), ("m", 8), ("s", 16))
+                if url.flags & mask
+            )
+        options: Dict[str, object] = {
+            "content": update_content or "attach",
+            "mode": update_mode or "minimal",
+            "harPath": None if is_zip else str(har),
+        }
+        if url_glob is not None:
+            options["urlGlob"] = url_glob
+        if url_regex_source is not None:
+            options["urlRegexSource"] = url_regex_source
+        if url_regex_flags is not None:
+            options["urlRegexFlags"] = url_regex_flags
+        if resourcesDir is not None:
+            options["resourcesDir"] = resourcesDir
+        params: Dict[str, Any] = {"options": options}
+        if page is not None:
+            params["page"] = page._channel
+        result = await self._channel.send_return_as_dict("harStart", None, params)
+        har_id = result["harId"]
+        self._har_recorders[har_id] = {"path": str(har)}
+        return har_id
+
+    async def _export_all_hars(self) -> None:
+        for har_id in list(self._har_recorders.keys()):
+            await self._export_har(har_id)
+        self._har_id = None
+
+    async def stop_har(self) -> None:
+        har_id = self._har_id
+        if not har_id:
+            return
+        self._har_id = None
+        await self._export_har(har_id)
+
+    async def _export_har(self, har_id: str) -> None:
+        params = self._har_recorders.pop(har_id, None)
+        if not params:
+            return
+        is_local = not self._connection.is_remote
+        is_zip = params["path"].endswith(".zip")
+
+        if is_local:
+            result = await self._channel.send_return_as_dict(
+                "harExport", None, {"harId": har_id, "mode": "entries"}
+            )
+            if not is_zip:
+                # Server wrote HAR and resources to the user's chosen paths.
+                return
+            await self._connection.local_utils.zip(
+                {
+                    "zipFile": params["path"],
+                    "entries": result["entries"],
+                    "mode": "write",
+                    "includeSources": False,
+                }
+            )
+            return
+
+        result = await self._channel.send_return_as_dict(
+            "harExport", None, {"harId": har_id, "mode": "archive"}
+        )
+        artifact = cast(Artifact, from_channel(result["artifact"]))
+        if is_zip:
+            await artifact.save_as(params["path"])
+            await artifact.delete()
+            return
+        # Uncompressed har is not supported in thin clients
+        await artifact.save_as(params["path"] + ".tmp")
+        await artifact.delete()
diff --git a/playwright/_impl/_transport.py b/playwright/_impl/_transport.py
index c53810eb9..3cc029e18 100644
--- a/playwright/_impl/_transport.py
+++ b/playwright/_impl/_transport.py
@@ -16,83 +16,169 @@
 import io
 import json
 import os
+import subprocess
 import sys
-from pathlib import Path
-from typing import Dict, Optional
+from abc import ABC, abstractmethod
+from typing import Callable, Dict, Optional, Union
+
+from playwright._impl._driver import compute_driver_executable, get_driver_env
+from playwright._impl._helper import ParsedMessagePayload
 
 
 # Sourced from: https://github.com/pytest-dev/pytest/blob/da01ee0a4bb0af780167ecd228ab3ad249511302/src/_pytest/faulthandler.py#L69-L77
 def _get_stderr_fileno() -> Optional[int]:
     try:
+        # when using pythonw, sys.stderr is None.
+        # when Pyinstaller is used, there is no closed attribute because Pyinstaller monkey-patches it with a NullWriter class
+        if sys.stderr is None or not hasattr(sys.stderr, "closed"):
+            return None
+        if sys.stderr.closed:
+            return None
+
         return sys.stderr.fileno()
-    except (AttributeError, io.UnsupportedOperation):
+    except (NotImplementedError, AttributeError, io.UnsupportedOperation):
         # pytest-xdist monkeypatches sys.stderr with an object that is not an actual file.
         # https://docs.python.org/3/library/faulthandler.html#issue-with-file-descriptors
         # This is potentially dangerous, but the best we can do.
-        if not hasattr(sys, "__stderr__"):
+        if not hasattr(sys, "__stderr__") or not sys.__stderr__:
             return None
         return sys.__stderr__.fileno()
 
 
-class Transport:
-    def __init__(self, driver_executable: Path) -> None:
-        super().__init__()
-        self.on_message = lambda _: None
-        self._stopped = False
-        self._driver_executable = driver_executable
-        self._loop: asyncio.AbstractEventLoop
+class Transport(ABC):
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self.on_message: Callable[[ParsedMessagePayload], None] = lambda _: None
+        self.on_error_future: asyncio.Future = loop.create_future()
 
-    def stop(self) -> None:
-        self._stopped = True
-        self._output.close()
+    @abstractmethod
+    def request_stop(self) -> None:
+        pass
+
+    def dispose(self) -> None:
+        pass
+
+    @abstractmethod
+    async def wait_until_stopped(self) -> None:
+        pass
 
+    @abstractmethod
+    async def connect(self) -> None:
+        pass
+
+    @abstractmethod
     async def run(self) -> None:
-        self._loop = asyncio.get_running_loop()
-
-        driver_env = os.environ.copy()
-        # VSCode's JavaScript Debug Terminal provides it but driver/pkg does not support it
-        driver_env.pop("NODE_OPTIONS", None)
-
-        proc = await asyncio.create_subprocess_exec(
-            str(self._driver_executable),
-            "run-driver",
-            env=driver_env,
-            stdin=asyncio.subprocess.PIPE,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=_get_stderr_fileno(),
-            limit=32768,
-        )
-        assert proc.stdout
-        assert proc.stdin
-        self._output = proc.stdin
-
-        while not self._stopped:
-            try:
-                buffer = await proc.stdout.readexactly(4)
-                length = int.from_bytes(buffer, byteorder="little", signed=False)
-                buffer = bytes(0)
-                while length:
-                    to_read = min(length, 32768)
-                    data = await proc.stdout.readexactly(to_read)
-                    length -= to_read
-                    if len(buffer):
-                        buffer = buffer + data
-                    else:
-                        buffer = data
-                obj = json.loads(buffer)
-
-                if "DEBUGP" in os.environ:  # pragma: no cover
-                    print("\x1b[33mRECV>\x1b[0m", json.dumps(obj, indent=2))
-                self.on_message(obj)
-            except asyncio.IncompleteReadError:
-                break
-            await asyncio.sleep(0)
+        pass
 
+    @abstractmethod
     def send(self, message: Dict) -> None:
+        pass
+
+    def serialize_message(self, message: Dict) -> bytes:
         msg = json.dumps(message)
         if "DEBUGP" in os.environ:  # pragma: no cover
             print("\x1b[32mSEND>\x1b[0m", json.dumps(message, indent=2))
-        data = msg.encode()
+        return msg.encode()
+
+    def deserialize_message(self, data: Union[str, bytes]) -> ParsedMessagePayload:
+        obj = json.loads(data)
+
+        if "DEBUGP" in os.environ:  # pragma: no cover
+            print("\x1b[33mRECV>\x1b[0m", json.dumps(obj, indent=2))
+        return obj
+
+
+class PipeTransport(Transport):
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        super().__init__(loop)
+        self._stopped = False
+
+    def request_stop(self) -> None:
+        assert self._output
+        self._stopped = True
+        self._output.close()
+
+    async def wait_until_stopped(self) -> None:
+        await self._stopped_future
+
+    async def connect(self) -> None:
+        self._stopped_future: asyncio.Future = asyncio.Future()
+
+        try:
+            # For pyinstaller and Nuitka
+            env = get_driver_env()
+            if getattr(sys, "frozen", False) or globals().get("__compiled__"):
+                env.setdefault("PLAYWRIGHT_BROWSERS_PATH", "0")
+
+            startupinfo = None
+            if sys.platform == "win32":
+                startupinfo = subprocess.STARTUPINFO()
+                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+                startupinfo.wShowWindow = subprocess.SW_HIDE
+
+            executable_path, entrypoint_path = compute_driver_executable()
+            self._proc = await asyncio.create_subprocess_exec(
+                executable_path,
+                entrypoint_path,
+                "run-driver",
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=_get_stderr_fileno(),
+                limit=32768,
+                env=env,
+                startupinfo=startupinfo,
+            )
+        except Exception as exc:
+            self.on_error_future.set_exception(exc)
+            raise exc
+
+        self._output = self._proc.stdin
+
+    async def run(self) -> None:
+        assert self._proc.stdout
+        assert self._proc.stdin
+        try:
+            while not self._stopped:
+                try:
+                    buffer = await self._proc.stdout.readexactly(4)
+                    if self._stopped:
+                        break
+                    length = int.from_bytes(buffer, byteorder="little", signed=False)
+                    buffer = bytes(0)
+                    while length:
+                        to_read = min(length, 32768)
+                        data = await self._proc.stdout.readexactly(to_read)
+                        if self._stopped:
+                            break
+                        length -= to_read
+                        if len(buffer):
+                            buffer = buffer + data
+                        else:
+                            buffer = data
+                    if self._stopped:
+                        break
+
+                    obj = self.deserialize_message(buffer)
+                    self.on_message(obj)
+                except asyncio.IncompleteReadError:
+                    if not self._stopped:
+                        self.on_error_future.set_exception(
+                            Exception("Connection closed while reading from the driver")
+                        )
+                    break
+                await asyncio.sleep(0)
+
+            await self._proc.communicate()
+        finally:
+            # Release waiters on wait_until_stopped() even if this task was
+            # cancelled before reaching the end (e.g. by asyncio.run()'s
+            # task-cancellation phase that runs before asyncio-atexit hooks).
+            if not self._stopped_future.done():
+                self._stopped_future.set_result(None)
+
+    def send(self, message: Dict) -> None:
+        assert self._output
+        data = self.serialize_message(message)
         self._output.write(
             len(data).to_bytes(4, byteorder="little", signed=False) + data
         )
diff --git a/playwright/_impl/_video.py b/playwright/_impl/_video.py
index 983501927..e991803e3 100644
--- a/playwright/_impl/_video.py
+++ b/playwright/_impl/_video.py
@@ -12,27 +12,45 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
-from typing import TYPE_CHECKING, cast
+import pathlib
+from typing import TYPE_CHECKING, Optional, Union
+
+from playwright._impl._artifact import Artifact
+from playwright._impl._helper import Error
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._page import Page
 
 
 class Video:
-    def __init__(self, page: "Page") -> None:
+    def __init__(self, page: "Page", artifact: Optional[Artifact]) -> None:
         self._loop = page._loop
         self._dispatcher_fiber = page._dispatcher_fiber
         self._page = page
-        self._path_future = page._loop.create_future()
+        self._is_remote = page._connection.is_remote
+        self._artifact = artifact
+
+    def __repr__(self) -> str:
+        return f"<Video page={self._page}>"
 
-    async def path(self) -> str:
-        return await self._path_future
+    async def path(self) -> pathlib.Path:
+        if self._is_remote:
+            raise Error(
+                "Path is not available when using browserType.connect(). Use save_as() to save a local copy."
+            )
+        if not self._artifact:
+            raise Error("Video recording has not been started.")
+        return self._artifact.absolute_path
 
-    def _set_relative_path(self, relative_path: str) -> None:
-        self._path_future.set_result(
-            os.path.join(
-                cast(str, self._page._browser_context._options["recordVideo"]["dir"]),
-                relative_path,
+    async def save_as(self, path: Union[str, pathlib.Path]) -> None:
+        if self._page._connection._is_sync and not self._page._is_closed:
+            raise Error(
+                "Page is not yet closed. Close the page prior to calling save_as"
             )
-        )
+        if not self._artifact:
+            raise Error("Video recording has not been started.")
+        await self._artifact.save_as(path)
+
+    async def delete(self) -> None:
+        if self._artifact:
+            await self._artifact.delete()
diff --git a/playwright/_impl/_wait_helper.py b/playwright/_impl/_wait_helper.py
deleted file mode 100644
index b4670d23e..000000000
--- a/playwright/_impl/_wait_helper.py
+++ /dev/null
@@ -1,89 +0,0 @@
-# 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 asyncio
-from typing import Any, Callable, List
-
-from pyee import EventEmitter
-
-from playwright._impl._api_types import Error, TimeoutError
-
-
-class WaitHelper:
-    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
-        self._failures: List[asyncio.Future] = []
-        self._loop = loop
-
-    def reject_on_event(
-        self,
-        emitter: EventEmitter,
-        event: str,
-        error: Error,
-        predicate: Callable[[Any], bool] = None,
-    ) -> None:
-        self.reject_on(wait_for_event_future(emitter, event, predicate), error)
-
-    def reject_on_timeout(self, timeout: int, message: str) -> None:
-        if timeout == 0:
-            return
-        self.reject_on(
-            self._loop.create_task(asyncio.sleep(timeout / 1000)), TimeoutError(message)
-        )
-
-    def reject_on(self, future: asyncio.Future, error: Error) -> None:
-        async def future_wrapper() -> Error:
-            await future
-            return error
-
-        result = self._loop.create_task(future_wrapper())
-        result.add_done_callback(lambda f: future.cancel())
-        self._failures.append(result)
-
-    async def wait_for_event(
-        self,
-        emitter: EventEmitter,
-        event: str,
-        predicate: Callable[[Any], bool] = None,
-    ) -> Any:
-        future = wait_for_event_future(emitter, event, predicate)
-        return await self.wait_for_future(future)
-
-    async def wait_for_future(self, future: asyncio.Future) -> Any:
-        done, _ = await asyncio.wait(
-            set([future, *self._failures]), return_when=asyncio.FIRST_COMPLETED
-        )
-        if future not in done:
-            future.cancel()
-        for failure in self._failures:
-            if failure not in done:
-                failure.cancel()
-        for failure in self._failures:
-            if failure in done:
-                raise failure.result()
-        return future.result()
-
-
-def wait_for_event_future(
-    emitter: EventEmitter, event: str, predicate: Callable[[Any], bool] = None
-) -> asyncio.Future:
-    future: asyncio.Future = asyncio.Future()
-
-    def listener(event_data: Any = None) -> None:
-        if not predicate or predicate(event_data):
-            future.set_result(event_data)
-
-    emitter.on(event, listener)
-
-    future.add_done_callback(lambda f: emitter.remove_listener(event, listener))
-    return future
diff --git a/playwright/_impl/_waiter.py b/playwright/_impl/_waiter.py
new file mode 100644
index 000000000..b5bf53382
--- /dev/null
+++ b/playwright/_impl/_waiter.py
@@ -0,0 +1,200 @@
+# 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 asyncio
+import inspect
+import math
+import uuid
+from asyncio.tasks import Task
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+from pyee import EventEmitter
+
+from playwright._impl._connection import ChannelOwner
+from playwright._impl._errors import Error, TimeoutError
+
+
+class Waiter:
+    def __init__(self, channel_owner: ChannelOwner, event: str) -> None:
+        self._result: asyncio.Future = asyncio.Future()
+        self._wait_id = uuid.uuid4().hex
+        self._loop = channel_owner._loop
+        self._pending_tasks: List[Task] = []
+        self._channel = channel_owner._channel
+        self._registered_listeners: List[Tuple[EventEmitter, str, Callable]] = []
+        self._logs: List[str] = []
+        self._wait_for_event_info_before(self._wait_id, event)
+
+    def _wait_for_event_info_before(self, wait_id: str, event: str) -> None:
+        self._channel.send_no_reply(
+            "waitForEventInfo",
+            None,
+            {
+                "info": {
+                    "waitId": wait_id,
+                    "phase": "before",
+                    "event": event,
+                }
+            },
+        )
+
+    def _wait_for_event_info_after(self, wait_id: str, error: Exception = None) -> None:
+        self._channel._connection.wrap_api_call_sync(
+            lambda: self._channel.send_no_reply(
+                "waitForEventInfo",
+                None,
+                {
+                    "info": {
+                        "waitId": wait_id,
+                        "phase": "after",
+                        **({"error": str(error)} if error else {}),
+                    },
+                },
+            ),
+            True,
+        )
+
+    def reject_on_event(
+        self,
+        emitter: EventEmitter,
+        event: str,
+        error: Union[Error, Callable[..., Error]],
+        predicate: Callable = None,
+    ) -> None:
+        def on_match() -> None:
+            self._reject(error() if callable(error) else error)
+
+        def listener(event_data: Any = None) -> None:
+            self._evaluate_predicate(predicate, event_data, on_match)
+
+        emitter.on(event, listener)
+        self._registered_listeners.append((emitter, event, listener))
+
+    def reject_on_timeout(self, timeout: float, message: str) -> None:
+        if timeout == 0:
+            return
+
+        async def reject() -> None:
+            await asyncio.sleep(timeout / 1000)
+            self._reject(TimeoutError(message))
+
+        self._pending_tasks.append(self._loop.create_task(reject()))
+
+    def _cleanup(self) -> None:
+        for task in self._pending_tasks:
+            if not task.done():
+                task.cancel()
+        for listener in self._registered_listeners:
+            listener[0].remove_listener(listener[1], listener[2])
+
+    def _fulfill(self, result: Any) -> None:
+        self._cleanup()
+        if not self._result.done():
+            self._result.set_result(result)
+        self._wait_for_event_info_after(self._wait_id)
+
+    def _reject(self, exception: Exception) -> None:
+        self._cleanup()
+        if exception:
+            base_class = TimeoutError if isinstance(exception, TimeoutError) else Error
+            exception = base_class(str(exception) + format_log_recording(self._logs))
+        if not self._result.done():
+            self._result.set_exception(exception)
+        self._wait_for_event_info_after(self._wait_id, exception)
+
+    def wait_for_event(
+        self,
+        emitter: EventEmitter,
+        event: str,
+        predicate: Callable = None,
+    ) -> None:
+        def listener(event_data: Any = None) -> None:
+            self._evaluate_predicate(
+                predicate, event_data, lambda: self._fulfill(event_data)
+            )
+
+        emitter.on(event, listener)
+        self._registered_listeners.append((emitter, event, listener))
+
+    def _evaluate_predicate(
+        self,
+        predicate: Optional[Callable],
+        event_data: Any,
+        on_match: Callable[[], None],
+    ) -> None:
+        if predicate is None:
+            on_match()
+            return
+        try:
+            result = predicate(event_data)
+        except Exception as e:
+            self._reject(e)
+            return
+        if inspect.iscoroutine(result):
+
+            async def _await_predicate(coro: Any) -> None:
+                try:
+                    matched = await coro
+                except Exception as e:
+                    self._reject(e)
+                    return
+                if matched and not self._result.done():
+                    on_match()
+
+            self._pending_tasks.append(self._loop.create_task(_await_predicate(result)))
+            return
+        if result:
+            on_match()
+
+    def result(self) -> asyncio.Future:
+        return self._result
+
+    def log(self, message: str) -> None:
+        self._logs.append(message)
+        try:
+            self._channel._connection.wrap_api_call_sync(
+                lambda: self._channel.send_no_reply(
+                    "waitForEventInfo",
+                    None,
+                    {
+                        "info": {
+                            "waitId": self._wait_id,
+                            "phase": "log",
+                            "message": message,
+                        },
+                    },
+                ),
+                True,
+            )
+        except Exception:
+            pass
+
+
+def throw_on_timeout(timeout: float, exception: Exception) -> asyncio.Task:
+    async def throw() -> None:
+        await asyncio.sleep(timeout / 1000)
+        raise exception
+
+    return asyncio.create_task(throw())
+
+
+def format_log_recording(log: List[str]) -> str:
+    if not log:
+        return ""
+    header = " logs "
+    header_length = 60
+    left_length = math.floor((header_length - len(header)) / 2)
+    right_length = header_length - len(header) - left_length
+    new_line = "\n"
+    return f"{new_line}{'=' * left_length}{header}{'=' * right_length}{new_line}{new_line.join(log)}{new_line}{'=' * header_length}"
diff --git a/playwright/_impl/_web_error.py b/playwright/_impl/_web_error.py
new file mode 100644
index 000000000..4527e8d4b
--- /dev/null
+++ b/playwright/_impl/_web_error.py
@@ -0,0 +1,48 @@
+# 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.
+
+from asyncio import AbstractEventLoop
+from typing import Any, Optional
+
+from playwright._impl._api_structures import WebErrorLocation
+from playwright._impl._helper import Error
+from playwright._impl._page import Page
+
+
+class WebError:
+    def __init__(
+        self,
+        loop: AbstractEventLoop,
+        dispatcher_fiber: Any,
+        page: Optional[Page],
+        error: Error,
+        location: WebErrorLocation,
+    ) -> None:
+        self._loop = loop
+        self._dispatcher_fiber = dispatcher_fiber
+        self._page = page
+        self._error = error
+        self._location = location
+
+    @property
+    def page(self) -> Optional[Page]:
+        return self._page
+
+    @property
+    def error(self) -> Error:
+        return self._error
+
+    @property
+    def location(self) -> WebErrorLocation:
+        return self._location
diff --git a/playwright/_impl/_writable_stream.py b/playwright/_impl/_writable_stream.py
new file mode 100644
index 000000000..7d5b7704b
--- /dev/null
+++ b/playwright/_impl/_writable_stream.py
@@ -0,0 +1,42 @@
+# 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 base64
+import os
+from pathlib import Path
+from typing import Dict, Union
+
+from playwright._impl._connection import ChannelOwner
+
+# COPY_BUFSIZE is taken from shutil.py in the standard library
+_WINDOWS = os.name == "nt"
+COPY_BUFSIZE = 1024 * 1024 if _WINDOWS else 64 * 1024
+
+
+class WritableStream(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+
+    async def copy(self, path: Union[str, Path]) -> None:
+        with open(path, "rb") as f:
+            while True:
+                data = f.read(COPY_BUFSIZE)
+                if not data:
+                    break
+                await self._channel.send(
+                    "write", None, {"binary": base64.b64encode(data).decode()}
+                )
+        await self._channel.send("close", None)
diff --git a/playwright/async_api/__init__.py b/playwright/async_api/__init__.py
index 95022c559..21ce850b4 100644
--- a/playwright/async_api/__init__.py
+++ b/playwright/async_api/__init__.py
@@ -18,28 +18,41 @@
 web automation that is ever-green, capable, reliable and fast.
 """
 
+from typing import Any, Optional, Union, overload
+
 import playwright._impl._api_structures
-import playwright._impl._api_types
+import playwright._impl._errors
+import playwright._impl._form_data
 import playwright.async_api._generated
+from playwright._impl._assertions import (
+    APIResponseAssertions as APIResponseAssertionsImpl,
+)
+from playwright._impl._assertions import LocatorAssertions as LocatorAssertionsImpl
+from playwright._impl._assertions import PageAssertions as PageAssertionsImpl
 from playwright.async_api._context_manager import PlaywrightContextManager
 from playwright.async_api._generated import (
-    Accessibility,
-    BindingCall,
+    APIRequest,
+    APIRequestContext,
+    APIResponse,
+    APIResponseAssertions,
     Browser,
     BrowserContext,
     BrowserType,
     CDPSession,
-    ChromiumBrowserContext,
     ConsoleMessage,
     Dialog,
     Download,
     ElementHandle,
     FileChooser,
     Frame,
+    FrameLocator,
     JSHandle,
     Keyboard,
+    Locator,
+    LocatorAssertions,
     Mouse,
     Page,
+    PageAssertions,
     Playwright,
     Request,
     Response,
@@ -47,41 +60,161 @@
     Selectors,
     Touchscreen,
     Video,
+    WebError,
     WebSocket,
+    WebSocketRoute,
     Worker,
 )
 
+ChromiumBrowserContext = BrowserContext
+
 Cookie = playwright._impl._api_structures.Cookie
+FilePayload = playwright._impl._api_structures.FilePayload
+FormData = playwright._impl._form_data.FormData
+FloatRect = playwright._impl._api_structures.FloatRect
+Geolocation = playwright._impl._api_structures.Geolocation
+HttpCredentials = playwright._impl._api_structures.HttpCredentials
+BrowserBindResult = playwright._impl._api_structures.BrowserBindResult
+DebuggerLocation = playwright._impl._api_structures.DebuggerLocation
+DebuggerPausedDetails = playwright._impl._api_structures.DebuggerPausedDetails
+PdfMargins = playwright._impl._api_structures.PdfMargins
+Position = playwright._impl._api_structures.Position
+ProxySettings = playwright._impl._api_structures.ProxySettings
 ResourceTiming = playwright._impl._api_structures.ResourceTiming
+ScreencastFrame = playwright._impl._api_structures.ScreencastFrame
+SourceLocation = playwright._impl._api_structures.SourceLocation
 StorageState = playwright._impl._api_structures.StorageState
+StorageStateCookie = playwright._impl._api_structures.StorageStateCookie
+ViewportSize = playwright._impl._api_structures.ViewportSize
 
-DeviceDescriptor = playwright._impl._api_types.DeviceDescriptor
-Error = playwright._impl._api_types.Error
-FilePayload = playwright._impl._api_types.FilePayload
-FloatRect = playwright._impl._api_types.FloatRect
-Geolocation = playwright._impl._api_types.Geolocation
-PdfMargins = playwright._impl._api_types.PdfMargins
-ProxySettings = playwright._impl._api_types.ProxySettings
-SourceLocation = playwright._impl._api_types.SourceLocation
-TimeoutError = playwright._impl._api_types.TimeoutError
+Error = playwright._impl._errors.Error
+TimeoutError = playwright._impl._errors.TimeoutError
 
 
 def async_playwright() -> PlaywrightContextManager:
     return PlaywrightContextManager()
 
 
+class Expect:
+    _unset: Any = object()
+
+    def __init__(self) -> None:
+        self._timeout: Optional[float] = None
+
+    def set_options(self, timeout: Optional[float] = _unset) -> None:
+        """
+        This method sets global `expect()` options.
+
+        Args:
+            timeout (float): Timeout value in milliseconds. Default to 5000 milliseconds.
+
+        Returns:
+            None
+        """
+        if timeout is not self._unset:
+            self._timeout = timeout
+
+    @overload
+    def __call__(
+        self, actual: Page, message: Optional[str] = None
+    ) -> PageAssertions: ...
+
+    @overload
+    def __call__(
+        self, actual: Locator, message: Optional[str] = None
+    ) -> LocatorAssertions: ...
+
+    @overload
+    def __call__(
+        self, actual: APIResponse, message: Optional[str] = None
+    ) -> APIResponseAssertions: ...
+
+    def __call__(
+        self, actual: Union[Page, Locator, APIResponse], message: Optional[str] = None
+    ) -> Union[PageAssertions, LocatorAssertions, APIResponseAssertions]:
+        return self._dispatch(actual, message, is_soft=False)
+
+    @overload
+    def soft(self, actual: Page, message: Optional[str] = None) -> PageAssertions: ...
+
+    @overload
+    def soft(
+        self, actual: Locator, message: Optional[str] = None
+    ) -> LocatorAssertions: ...
+
+    @overload
+    def soft(
+        self, actual: APIResponse, message: Optional[str] = None
+    ) -> APIResponseAssertions: ...
+
+    def soft(
+        self, actual: Union[Page, Locator, APIResponse], message: Optional[str] = None
+    ) -> Union[PageAssertions, LocatorAssertions, APIResponseAssertions]:
+        """
+        Creates a [soft assertion](https://playwright.dev/python/docs/test-assertions#soft-assertions).
+        Failing soft assertions do not abort test execution, but mark the test
+        as failed. Multiple failures from the same test are surfaced together
+        at the end of the test.
+
+        Requires the [pytest-playwright](https://pypi.org/project/pytest-playwright/)
+        plugin to establish the per-test scope that collects soft assertion
+        failures.
+        """
+        return self._dispatch(actual, message, is_soft=True)
+
+    def _dispatch(
+        self,
+        actual: Union[Page, Locator, APIResponse],
+        message: Optional[str],
+        is_soft: bool,
+    ) -> Union[PageAssertions, LocatorAssertions, APIResponseAssertions]:
+        if isinstance(actual, Page):
+            return PageAssertions(
+                PageAssertionsImpl(
+                    actual._impl_obj,
+                    self._timeout,
+                    message=message,
+                    is_soft=is_soft,
+                )
+            )
+        elif isinstance(actual, Locator):
+            return LocatorAssertions(
+                LocatorAssertionsImpl(
+                    actual._impl_obj,
+                    self._timeout,
+                    message=message,
+                    is_soft=is_soft,
+                )
+            )
+        elif isinstance(actual, APIResponse):
+            return APIResponseAssertions(
+                APIResponseAssertionsImpl(
+                    actual._impl_obj,
+                    self._timeout,
+                    message=message,
+                    is_soft=is_soft,
+                )
+            )
+        raise ValueError(f"Unsupported type: {type(actual)}")
+
+
+expect = Expect()
+
+
 __all__ = [
+    "expect",
     "async_playwright",
-    "Accessibility",
-    "BindingCall",
+    "APIRequest",
+    "APIRequestContext",
+    "APIResponse",
     "Browser",
+    "BrowserBindResult",
     "BrowserContext",
     "BrowserType",
     "CDPSession",
     "ChromiumBrowserContext",
     "ConsoleMessage",
     "Cookie",
-    "DeviceDescriptor",
     "Dialog",
     "Download",
     "ElementHandle",
@@ -89,26 +222,37 @@ def async_playwright() -> PlaywrightContextManager:
     "FileChooser",
     "FilePayload",
     "FloatRect",
+    "FormData",
     "Frame",
+    "FrameLocator",
     "Geolocation",
+    "HttpCredentials",
     "JSHandle",
     "Keyboard",
+    "Locator",
     "Mouse",
+    "DebuggerLocation",
+    "DebuggerPausedDetails",
     "Page",
     "PdfMargins",
+    "Position",
     "Playwright",
     "ProxySettings",
     "Request",
     "ResourceTiming",
     "Response",
     "Route",
+    "ScreencastFrame",
     "Selectors",
     "SourceLocation",
     "StorageState",
-    "sync_playwright",
+    "StorageStateCookie",
     "TimeoutError",
     "Touchscreen",
     "Video",
+    "ViewportSize",
+    "WebError",
     "WebSocket",
+    "WebSocketRoute",
     "Worker",
 ]
diff --git a/playwright/async_api/_context_manager.py b/playwright/async_api/_context_manager.py
index 16821e762..0c93f7043 100644
--- a/playwright/async_api/_context_manager.py
+++ b/playwright/async_api/_context_manager.py
@@ -16,25 +16,34 @@
 from typing import Any
 
 from playwright._impl._connection import Connection
-from playwright._impl._driver import compute_driver_executable
 from playwright._impl._object_factory import create_remote_object
+from playwright._impl._transport import PipeTransport
 from playwright.async_api._generated import Playwright as AsyncPlaywright
 
 
 class PlaywrightContextManager:
     def __init__(self) -> None:
         self._connection: Connection
+        self._exit_was_called = False
 
     async def __aenter__(self) -> AsyncPlaywright:
+        loop = asyncio.get_running_loop()
         self._connection = Connection(
-            None, create_remote_object, compute_driver_executable()
+            None,
+            create_remote_object,
+            PipeTransport(loop),
+            loop,
         )
-        loop = asyncio.get_running_loop()
-        self._connection._loop = loop
         loop.create_task(self._connection.run())
-        playwright = AsyncPlaywright(
-            await self._connection.wait_for_object_with_known_name("Playwright")
+        playwright_future = self._connection.playwright_future
+
+        done, _ = await asyncio.wait(
+            {self._connection._transport.on_error_future, playwright_future},
+            return_when=asyncio.FIRST_COMPLETED,
         )
+        if not playwright_future.done():
+            playwright_future.cancel()
+        playwright = AsyncPlaywright(next(iter(done)).result())
         playwright.stop = self.__aexit__  # type: ignore
         return playwright
 
@@ -42,4 +51,7 @@ async def start(self) -> AsyncPlaywright:
         return await self.__aenter__()
 
     async def __aexit__(self, *args: Any) -> None:
-        self._connection.stop_async()
+        if self._exit_was_called:
+            return
+        self._exit_was_called = True
+        await self._connection.stop_async()
diff --git a/playwright/async_api/_generated.py b/playwright/async_api/_generated.py
index 174f34dc8..229ba6d8c 100644
--- a/playwright/async_api/_generated.py
+++ b/playwright/async_api/_generated.py
@@ -13,62 +13,90 @@
 # limitations under the License.
 
 
+import datetime
 import pathlib
-import sys
 import typing
-
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import Literal
-else:  # pragma: no cover
-    from typing_extensions import Literal
-
-from playwright._impl._accessibility import Accessibility as AccessibilityImpl
-from playwright._impl._api_structures import Cookie, ResourceTiming, StorageState
-from playwright._impl._api_types import (
-    DeviceDescriptor,
+from typing import Literal
+
+from playwright._impl._api_structures import (
+    BrowserBindResult,
+    ClientCertificate,
+    Cookie,
+    DebuggerLocation,
+    DebuggerPausedDetails,
+    DropPayload,
     FilePayload,
     FloatRect,
     Geolocation,
+    HttpCredentials,
+    NameValue,
     PdfMargins,
+    Position,
     ProxySettings,
+    RemoteAddr,
+    RequestSizes,
+    ResourceTiming,
+    ScreencastFrame,
+    SecurityDetails,
+    SetCookieParam,
     SourceLocation,
+    StorageState,
+    TracingGroupLocation,
+    ViewportSize,
+    WebErrorLocation,
+)
+from playwright._impl._assertions import (
+    APIResponseAssertions as APIResponseAssertionsImpl,
+)
+from playwright._impl._assertions import LocatorAssertions as LocatorAssertionsImpl
+from playwright._impl._assertions import PageAssertions as PageAssertionsImpl
+from playwright._impl._async_base import (
+    AsyncBase,
+    AsyncContextManager,
+    AsyncEventContextManager,
+    mapping,
 )
-from playwright._impl._async_base import AsyncBase, AsyncEventContextManager, mapping
 from playwright._impl._browser import Browser as BrowserImpl
 from playwright._impl._browser_context import BrowserContext as BrowserContextImpl
 from playwright._impl._browser_type import BrowserType as BrowserTypeImpl
 from playwright._impl._cdp_session import CDPSession as CDPSessionImpl
-from playwright._impl._chromium_browser_context import (
-    ChromiumBrowserContext as ChromiumBrowserContextImpl,
-)
+from playwright._impl._clock import Clock as ClockImpl
 from playwright._impl._console_message import ConsoleMessage as ConsoleMessageImpl
+from playwright._impl._debugger import Debugger as DebuggerImpl
 from playwright._impl._dialog import Dialog as DialogImpl
+from playwright._impl._disposable import Disposable as DisposableImpl
 from playwright._impl._download import Download as DownloadImpl
 from playwright._impl._element_handle import ElementHandle as ElementHandleImpl
+from playwright._impl._errors import Error
+from playwright._impl._fetch import APIRequest as APIRequestImpl
+from playwright._impl._fetch import APIRequestContext as APIRequestContextImpl
+from playwright._impl._fetch import APIResponse as APIResponseImpl
 from playwright._impl._file_chooser import FileChooser as FileChooserImpl
+from playwright._impl._form_data import FormData
 from playwright._impl._frame import Frame as FrameImpl
+from playwright._impl._helper import to_milliseconds
 from playwright._impl._input import Keyboard as KeyboardImpl
 from playwright._impl._input import Mouse as MouseImpl
 from playwright._impl._input import Touchscreen as TouchscreenImpl
 from playwright._impl._js_handle import JSHandle as JSHandleImpl
-from playwright._impl._logger import log_api
+from playwright._impl._locator import FrameLocator as FrameLocatorImpl
+from playwright._impl._locator import Locator as LocatorImpl
 from playwright._impl._network import Request as RequestImpl
 from playwright._impl._network import Response as ResponseImpl
 from playwright._impl._network import Route as RouteImpl
 from playwright._impl._network import WebSocket as WebSocketImpl
-from playwright._impl._page import BindingCall as BindingCallImpl
+from playwright._impl._network import WebSocketRoute as WebSocketRouteImpl
 from playwright._impl._page import Page as PageImpl
 from playwright._impl._page import Worker as WorkerImpl
 from playwright._impl._playwright import Playwright as PlaywrightImpl
+from playwright._impl._screencast import Screencast as ScreencastImpl
 from playwright._impl._selectors import Selectors as SelectorsImpl
+from playwright._impl._tracing import Tracing as TracingImpl
 from playwright._impl._video import Video as VideoImpl
-
-NoneType = type(None)
+from playwright._impl._web_error import WebError as WebErrorImpl
 
 
 class Request(AsyncBase):
-    def __init__(self, obj: RequestImpl):
-        super().__init__(obj)
 
     @property
     def url(self) -> str:
@@ -87,14 +115,32 @@ def resource_type(self) -> str:
         """Request.resource_type
 
         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`.
+        following: `document`, `stylesheet`, `image`, `media`, `font`, `script`, `texttrack`, `xhr`, `fetch`,
+        `eventsource`, `websocket`, `manifest`, `other`.
 
         Returns
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.resourceType)
+        return mapping.from_maybe_impl(self._impl_obj.resource_type)
+
+    @property
+    def service_worker(self) -> typing.Optional["Worker"]:
+        """Request.service_worker
+
+        The Service `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()` available.
+
+        Returns
+        -------
+        Union[Worker, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.service_worker)
 
     @property
     def method(self) -> str:
@@ -109,162 +155,282 @@ def method(self) -> str:
         return mapping.from_maybe_impl(self._impl_obj.method)
 
     @property
-    def post_data(self) -> typing.Union[str, NoneType]:
+    def post_data(self) -> typing.Optional[str]:
         """Request.post_data
 
         Request's post body, if any.
 
         Returns
         -------
-        Optional[str]
+        Union[str, None]
         """
-        return mapping.from_maybe_impl(self._impl_obj.postData)
+        return mapping.from_maybe_impl(self._impl_obj.post_data)
 
     @property
-    def post_data_json(self) -> typing.Union[typing.Dict, NoneType]:
+    def post_data_json(self) -> typing.Optional[typing.Any]:
         """Request.post_data_json
 
         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.
 
         Returns
         -------
-        Optional[Dict]
+        Union[Any, None]
         """
-        return mapping.from_maybe_impl(self._impl_obj.postDataJSON)
+        return mapping.from_maybe_impl(self._impl_obj.post_data_json)
 
     @property
-    def post_data_buffer(self) -> typing.Union[bytes, NoneType]:
+    def post_data_buffer(self) -> typing.Optional[bytes]:
         """Request.post_data_buffer
 
         Request's post body in a binary form, if any.
 
         Returns
         -------
-        Optional[bytes]
+        Union[bytes, None]
         """
-        return mapping.from_maybe_impl(self._impl_obj.postDataBuffer)
+        return mapping.from_maybe_impl(self._impl_obj.post_data_buffer)
 
     @property
-    def headers(self) -> typing.Dict[str, str]:
-        """Request.headers
+    def existing_response(self) -> typing.Optional["Response"]:
+        """Request.existing_response
+
+        Returns the `Response` object if the response has already been received, `null` otherwise.
 
-        An object with HTTP headers associated with the request. All header names are lower-case.
+        Unlike `request.response()`, this method does not wait for the response to arrive. It returns immediately
+        with the response object if the response has been received, or `null` if the response has not been received yet.
 
         Returns
         -------
-        Dict[str, str]
+        Union[Response, None]
         """
-        return mapping.from_maybe_impl(self._impl_obj.headers)
+        return mapping.from_impl_nullable(self._impl_obj.existing_response)
 
     @property
     def frame(self) -> "Frame":
         """Request.frame
 
-        Returns the Frame that initiated this request.
+        Returns the `Frame` that initiated this request.
 
-        Returns
-        -------
-        Frame
-        """
-        return mapping.from_impl(self._impl_obj.frame)
+        **Usage**
 
-    @property
-    def is_navigation_request(self) -> bool:
-        """Request.is_navigation_request
+        ```py
+        frame_url = request.frame.url
+        ```
 
-        Whether this request is driving frame's navigation.
+        **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.is_navigation_request()` to check that.
+
+        Here is an example that handles all the cases:
 
         Returns
         -------
-        bool
+        Frame
         """
-        return mapping.from_maybe_impl(self._impl_obj.isNavigationRequest)
+        return mapping.from_impl(self._impl_obj.frame)
 
     @property
-    def redirected_from(self) -> typing.Union["Request", NoneType]:
+    def redirected_from(self) -> typing.Optional["Request"]:
         """Request.redirected_from
 
         Request that was redirected by the server to this one, if any.
-        When the server responds with a redirect, Playwright creates a new Request object. The two requests are connected by
-        `redirectedFrom()` and `redirectedTo()` methods. When multiple server redirects has happened, it is possible to
+
+        When the server responds with a redirect, Playwright creates a new `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`:
+
+        ```py
+        response = await page.goto(\"http://example.com\")
+        print(response.request.redirected_from.url) # \"http://example.com\"
+        ```
+
         If the website `https://google.com` has no redirects:
 
+        ```py
+        response = await page.goto(\"https://google.com\")
+        print(response.request.redirected_from) # None
+        ```
+
         Returns
         -------
-        Optional[Request]
+        Union[Request, None]
         """
-        return mapping.from_impl_nullable(self._impl_obj.redirectedFrom)
+        return mapping.from_impl_nullable(self._impl_obj.redirected_from)
 
     @property
-    def redirected_to(self) -> typing.Union["Request", NoneType]:
+    def redirected_to(self) -> typing.Optional["Request"]:
         """Request.redirected_to
 
         New request issued by the browser if the server responded with redirect.
-        This method is the opposite of request.redirected_from():
+
+        **Usage**
+
+        This method is the opposite of `request.redirected_from()`:
+
+        ```py
+        assert request.redirected_from.redirected_to == request
+        ```
 
         Returns
         -------
-        Optional[Request]
+        Union[Request, None]
         """
-        return mapping.from_impl_nullable(self._impl_obj.redirectedTo)
+        return mapping.from_impl_nullable(self._impl_obj.redirected_to)
 
     @property
-    def failure(self) -> typing.Union[str, NoneType]:
+    def failure(self) -> typing.Optional[str]:
         """Request.failure
 
         The method returns `null` unless this request has failed, as reported by `requestfailed` event.
+
+        **Usage**
+
         Example of logging of all the failed requests:
 
+        ```py
+        page.on(\"requestfailed\", lambda request: print(request.url + \" \" + request.failure))
+        ```
+
         Returns
         -------
-        Optional[str]
+        Union[str, None]
         """
         return mapping.from_maybe_impl(self._impl_obj.failure)
 
     @property
-    def timing(self) -> "ResourceTiming":
+    def timing(self) -> ResourceTiming:
         """Request.timing
 
-        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.
+        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**
+
+        ```py
+        async with page.expect_event(\"requestfinished\") as request_info:
+            await page.goto(\"http://example.com\")
+        request = await request_info.value
+        print(request.timing)
+        ```
 
         Returns
         -------
-        {"startTime": float, "domainLookupStart": float, "domainLookupEnd": float, "connectStart": float, "secureConnectionStart": float, "connectEnd": float, "requestStart": float, "responseStart": float, "responseEnd": float}
+        {startTime: float, domainLookupStart: float, domainLookupEnd: float, connectStart: float, secureConnectionStart: float, connectEnd: float, requestStart: float, responseStart: float, responseEnd: float}
         """
         return mapping.from_impl(self._impl_obj.timing)
 
-    async def response(self) -> typing.Union["Response", NoneType]:
+    @property
+    def headers(self) -> typing.Dict[str, str]:
+        """Request.headers
+
+        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.all_headers()` for complete
+        list of headers that include `cookie` information.
+
+        Returns
+        -------
+        Dict[str, str]
+        """
+        return mapping.from_maybe_impl(self._impl_obj.headers)
+
+    async def sizes(self) -> RequestSizes:
+        """Request.sizes
+
+        Returns resource size information for given request.
+
+        Returns
+        -------
+        {requestBodySize: int, requestHeadersSize: int, responseBodySize: int, responseHeadersSize: int}
+        """
+
+        return mapping.from_impl(await self._impl_obj.sizes())
+
+    async def response(self) -> typing.Optional["Response"]:
         """Request.response
 
-        Returns the matching Response object, or `null` if the response was not received due to error.
+        Returns the matching `Response` object, or `null` if the response was not received due to error.
 
         Returns
         -------
-        Optional[Response]
+        Union[Response, None]
         """
 
-        try:
-            log_api("=> request.response started")
-            result = mapping.from_impl_nullable(await self._impl_obj.response())
-            log_api("<= request.response succeded")
-            return result
-        except Exception as e:
-            log_api("<= request.response failed")
-            raise e
+        return mapping.from_impl_nullable(await self._impl_obj.response())
+
+    def is_navigation_request(self) -> bool:
+        """Request.is_navigation_request
+
+        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()` available.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.is_navigation_request())
+
+    async def all_headers(self) -> typing.Dict[str, str]:
+        """Request.all_headers
+
+        An object with all the request HTTP headers associated with this request. The header names are lower-cased.
+
+        Returns
+        -------
+        Dict[str, str]
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.all_headers())
+
+    async def headers_array(self) -> typing.List[NameValue]:
+        """Request.headers_array
+
+        An array with all the request HTTP headers associated with this request. Unlike `request.all_headers()`,
+        header names are NOT lower-cased. Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple
+        times.
+
+        Returns
+        -------
+        List[{name: str, value: str}]
+        """
+
+        return mapping.from_impl_list(await self._impl_obj.headers_array())
+
+    async def header_value(self, name: str) -> typing.Optional[str]:
+        """Request.header_value
+
+        Returns the value of the header matching the name. The name is case-insensitive.
+
+        Parameters
+        ----------
+        name : str
+            Name of the header.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.header_value(name=name))
 
 
 mapping.register(RequestImpl, Request)
 
 
 class Response(AsyncBase):
-    def __init__(self, obj: ResponseImpl):
-        super().__init__(obj)
 
     @property
     def url(self) -> str:
@@ -306,19 +472,21 @@ def status(self) -> int:
     def status_text(self) -> str:
         """Response.status_text
 
-        Contains the status text of the response (e.g. usually an "OK" for a success).
+        Contains the status text of the response (e.g. usually an \"OK\" for a success).
 
         Returns
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.statusText)
+        return mapping.from_maybe_impl(self._impl_obj.status_text)
 
     @property
     def headers(self) -> typing.Dict[str, str]:
         """Response.headers
 
-        Returns the object with HTTP headers associated with the response. All header names are lower-case.
+        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.all_headers()` for complete
+        list of headers that include `cookie` information.
 
         Returns
         -------
@@ -326,11 +494,24 @@ def headers(self) -> typing.Dict[str, str]:
         """
         return mapping.from_maybe_impl(self._impl_obj.headers)
 
+    @property
+    def from_service_worker(self) -> bool:
+        """Response.from_service_worker
+
+        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)).
+
+        Returns
+        -------
+        bool
+        """
+        return mapping.from_maybe_impl(self._impl_obj.from_service_worker)
+
     @property
     def request(self) -> "Request":
         """Response.request
 
-        Returns the matching Request object.
+        Returns the matching `Request` object.
 
         Returns
         -------
@@ -342,7 +523,7 @@ def request(self) -> "Request":
     def frame(self) -> "Frame":
         """Response.frame
 
-        Returns the Frame that initiated this response.
+        Returns the `Frame` that initiated this response.
 
         Returns
         -------
@@ -350,24 +531,111 @@ def frame(self) -> "Frame":
         """
         return mapping.from_impl(self._impl_obj.frame)
 
-    async def finished(self) -> typing.Union[str, NoneType]:
-        """Response.finished
+    async def all_headers(self) -> typing.Dict[str, str]:
+        """Response.all_headers
 
-        Waits for this response to finish, returns failure error if request failed.
+        An object with all the response HTTP headers associated with this response.
 
         Returns
         -------
-        Optional[str]
+        Dict[str, str]
         """
 
-        try:
-            log_api("=> response.finished started")
-            result = mapping.from_maybe_impl(await self._impl_obj.finished())
-            log_api("<= response.finished succeded")
-            return result
-        except Exception as e:
-            log_api("<= response.finished failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.all_headers())
+
+    async def headers_array(self) -> typing.List[NameValue]:
+        """Response.headers_array
+
+        An array with all the request HTTP headers associated with this response. Unlike `response.all_headers()`,
+        header names are NOT lower-cased. Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple
+        times.
+
+        Returns
+        -------
+        List[{name: str, value: str}]
+        """
+
+        return mapping.from_impl_list(await self._impl_obj.headers_array())
+
+    async def header_value(self, name: str) -> typing.Optional[str]:
+        """Response.header_value
+
+        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.
+
+        Parameters
+        ----------
+        name : str
+            Name of the header.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.header_value(name=name))
+
+    async def header_values(self, name: str) -> typing.List[str]:
+        """Response.header_values
+
+        Returns all values of the headers matching the name, for example `set-cookie`. The name is case-insensitive.
+
+        Parameters
+        ----------
+        name : str
+            Name of the header.
+
+        Returns
+        -------
+        List[str]
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.header_values(name=name))
+
+    async def server_addr(self) -> typing.Optional[RemoteAddr]:
+        """Response.server_addr
+
+        Returns the IP address and port of the server.
+
+        Returns
+        -------
+        Union[{ipAddress: str, port: int}, None]
+        """
+
+        return mapping.from_impl_nullable(await self._impl_obj.server_addr())
+
+    async def security_details(self) -> typing.Optional[SecurityDetails]:
+        """Response.security_details
+
+        Returns SSL and other security information.
+
+        Returns
+        -------
+        Union[{issuer: Union[str, None], protocol: Union[str, None], subjectName: Union[str, None], validFrom: Union[float, None], validTo: Union[float, None]}, None]
+        """
+
+        return mapping.from_impl_nullable(await self._impl_obj.security_details())
+
+    async def http_version(self) -> str:
+        """Response.http_version
+
+        Returns the http version used by the response.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.http_version())
+
+    async def finished(self) -> None:
+        """Response.finished
+
+        Waits for this response to finish, returns always `null`.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.finished())
 
     async def body(self) -> bytes:
         """Response.body
@@ -379,14 +647,7 @@ async def body(self) -> bytes:
         bytes
         """
 
-        try:
-            log_api("=> response.body started")
-            result = mapping.from_maybe_impl(await self._impl_obj.body())
-            log_api("<= response.body succeded")
-            return result
-        except Exception as e:
-            log_api("<= response.body failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.body())
 
     async def text(self) -> str:
         """Response.text
@@ -398,42 +659,27 @@ async def text(self) -> str:
         str
         """
 
-        try:
-            log_api("=> response.text started")
-            result = mapping.from_maybe_impl(await self._impl_obj.text())
-            log_api("<= response.text succeded")
-            return result
-        except Exception as e:
-            log_api("<= response.text failed")
-            raise e
-
-    async def json(self) -> typing.Union[typing.Dict, typing.List]:
+        return mapping.from_maybe_impl(await self._impl_obj.text())
+
+    async def json(self) -> typing.Any:
         """Response.json
 
         Returns the JSON representation of response body.
+
         This method will throw if the response body is not parsable via `JSON.parse`.
 
         Returns
         -------
-        Union[Dict, List]
+        Any
         """
 
-        try:
-            log_api("=> response.json started")
-            result = mapping.from_maybe_impl(await self._impl_obj.json())
-            log_api("<= response.json succeded")
-            return result
-        except Exception as e:
-            log_api("<= response.json failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.json())
 
 
 mapping.register(ResponseImpl, Response)
 
 
 class Route(AsyncBase):
-    def __init__(self, obj: RouteImpl):
-        super().__init__(obj)
 
     @property
     def request(self) -> "Request":
@@ -447,210 +693,606 @@ def request(self) -> "Request":
         """
         return mapping.from_impl(self._impl_obj.request)
 
-    async def abort(self, error_code: str = None) -> NoneType:
+    async def abort(self, error_code: typing.Optional[str] = None) -> None:
         """Route.abort
 
         Aborts the route's request.
 
         Parameters
         ----------
-        error_code : Optional[str]
+        error_code : Union[str, None]
             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.
-        """
-
-        try:
-            log_api("=> route.abort started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.abort(errorCode=error_code)
-            )
-            log_api("<= route.abort succeded")
-            return result
-        except Exception as e:
-            log_api("<= route.abort failed")
-            raise e
+            - `'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.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.abort(errorCode=error_code))
 
     async def fulfill(
         self,
-        status: int = None,
-        headers: typing.Union[typing.Dict[str, str]] = None,
-        body: typing.Union[str, bytes] = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content_type: str = None,
-    ) -> NoneType:
+        *,
+        status: typing.Optional[int] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        body: typing.Optional[typing.Union[str, bytes]] = None,
+        json: typing.Optional[typing.Any] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content_type: typing.Optional[str] = None,
+        response: typing.Optional["APIResponse"] = None,
+    ) -> None:
         """Route.fulfill
 
         Fulfills route's request with given response.
+
+        **Usage**
+
         An example of fulfilling all requests with 404 responses:
+
+        ```py
+        await page.route(\"**/*\", lambda route: route.fulfill(
+            status=404,
+            content_type=\"text/plain\",
+            body=\"not found!\"))
+        ```
+
         An example of serving static file:
 
+        ```py
+        await page.route(\"**/xhr_endpoint\", lambda route: route.fulfill(path=\"mock_data.json\"))
+        ```
+
         Parameters
         ----------
-        status : Optional[int]
+        status : Union[int, None]
             Response status code, defaults to `200`.
-        headers : Optional[Dict[str, str]]
-            Optional response headers. Header values will be converted to a string.
-        body : Union[str, bytes, NoneType]
-            Optional response body.
-        path : Union[str, pathlib.Path, NoneType]
-            Optional 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 current working directory.
-        content_type : Optional[str]
+        headers : Union[Dict[str, str], None]
+            Response headers. Header values will be converted to a string.
+        body : Union[bytes, str, None]
+            Response body.
+        json : Union[Any, None]
+            JSON response. This method will set the content type to `application/json` if not set.
+        path : Union[pathlib.Path, str, None]
+            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.
+        content_type : Union[str, None]
             If set, equals to setting `Content-Type` response header.
-        """
-
-        try:
-            log_api("=> route.fulfill started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.fulfill(
-                    status=status,
-                    headers=mapping.to_impl(headers),
-                    body=body,
-                    path=path,
-                    contentType=content_type,
-                )
-            )
-            log_api("<= route.fulfill succeded")
-            return result
-        except Exception as e:
-            log_api("<= route.fulfill failed")
-            raise e
+        response : Union[APIResponse, None]
+            `APIResponse` to fulfill route's request with. Individual fields of the response (such as headers) can be
+            overridden using fulfill options.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.fulfill(
+                status=status,
+                headers=mapping.to_impl(headers),
+                body=body,
+                json=mapping.to_impl(json),
+                path=path,
+                contentType=content_type,
+                response=response._impl_obj if response else None,
+            )
+        )
 
-    async def continue_(
+    async def fetch(
         self,
-        url: str = None,
-        method: str = None,
-        headers: typing.Union[typing.Dict[str, str]] = None,
-        post_data: typing.Union[str, bytes] = None,
-    ) -> NoneType:
-        """Route.continue_
+        *,
+        url: typing.Optional[str] = None,
+        method: typing.Optional[str] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> "APIResponse":
+        """Route.fetch
+
+        Performs the request and fetches result without fulfilling it, so that the response could be modified and then
+        fulfilled.
+
+        **Usage**
+
+        ```py
+        async def handle(route):
+            response = await route.fetch()
+            json = await response.json()
+            json[\"message\"][\"big_red_dog\"] = []
+            await route.fulfill(response=response, json=json)
+
+        await page.route(\"https://dog.ceo/api/breeds/list/all\", handle)
+        ```
 
-        Continues route's request with optional overrides.
+        **Details**
+
+        Note that `headers` option will apply to the fetched request as well as any redirects initiated by it. If you want
+        to only apply `headers` to the original request, but not to redirects, look into `route.continue_()`
+        instead.
 
         Parameters
         ----------
-        url : Optional[str]
+        url : Union[str, None]
             If set changes the request URL. New URL must have same protocol as original one.
-        method : Optional[str]
-            If set changes the request method (e.g. GET or POST)
-        headers : Optional[Dict[str, str]]
+        method : Union[str, None]
+            If set changes the request method (e.g. GET or POST).
+        headers : Union[Dict[str, str], None]
             If set changes the request HTTP headers. Header values will be converted to a string.
-        post_data : Union[str, bytes, NoneType]
-            If set changes the post data of request
-        """
+        post_data : Union[Any, bytes, str, None]
+            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.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
 
-        try:
-            log_api("=> route.continue_ started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.continue_(
-                    url=url,
-                    method=method,
-                    headers=mapping.to_impl(headers),
-                    postData=post_data,
-                )
-            )
-            log_api("<= route.continue_ succeded")
-            return result
-        except Exception as e:
-            log_api("<= route.continue_ failed")
-            raise e
+        Returns
+        -------
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.fetch(
+                url=url,
+                method=method,
+                headers=mapping.to_impl(headers),
+                postData=mapping.to_impl(post_data),
+                maxRedirects=max_redirects,
+                maxRetries=max_retries,
+                timeout=to_milliseconds(timeout),
+            )
+        )
 
+    async def fallback(
+        self,
+        *,
+        url: typing.Optional[str] = None,
+        method: typing.Optional[str] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+    ) -> None:
+        """Route.fallback
+
+        Continues route's request with optional overrides. The method is similar to `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.
+
+        ```py
+        await page.route(\"**/*\", lambda route: route.abort())  # Runs last.
+        await page.route(\"**/*\", lambda route: route.fallback())  # Runs second.
+        await page.route(\"**/*\", lambda route: route.fallback())  # Runs first.
+        ```
 
-mapping.register(RouteImpl, Route)
+        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.
+
+        ```py
+        # Handle GET requests.
+        async def handle_get(route):
+            if route.request.method != \"GET\":
+                await route.fallback()
+                return
+          # Handling GET only.
+          # ...
+
+        # Handle POST requests.
+        async def handle_post(route):
+            if route.request.method != \"POST\":
+                await route.fallback()
+                return
+          # Handling POST only.
+          # ...
+
+        await page.route(\"**/*\", handle_get)
+        await page.route(\"**/*\", handle_post)
+        ```
 
+        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.
 
-class WebSocket(AsyncBase):
-    def __init__(self, obj: WebSocketImpl):
-        super().__init__(obj)
+        ```py
+        async def handle(route, request):
+            # override headers
+            headers = {
+                **request.headers,
+                \"foo\": \"foo-value\", # set \"foo\" header
+                \"bar\": None # remove \"bar\" header
+            }
+            await route.fallback(headers=headers)
 
-    @property
-    def url(self) -> str:
-        """WebSocket.url
+        await page.route(\"**/*\", handle)
+        ```
 
-        Contains the URL of the WebSocket.
+        Use `route.continue_()` to immediately send the request to the network, other matching handlers won't be
+        invoked in that case.
 
-        Returns
-        -------
-        str
+        Parameters
+        ----------
+        url : Union[str, None]
+            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.
+        method : Union[str, None]
+            If set changes the request method (e.g. GET or POST).
+        headers : Union[Dict[str, str], None]
+            If set changes the request HTTP headers. Header values will be converted to a string.
+        post_data : Union[Any, bytes, str, None]
+            If set changes the post data of request.
         """
-        return mapping.from_maybe_impl(self._impl_obj.url)
 
-    async def wait_for_event(
+        return mapping.from_maybe_impl(
+            await self._impl_obj.fallback(
+                url=url,
+                method=method,
+                headers=mapping.to_impl(headers),
+                postData=mapping.to_impl(post_data),
+            )
+        )
+
+    async def continue_(
         self,
-        event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
-    ) -> typing.Any:
-        """WebSocket.wait_for_event
+        *,
+        url: typing.Optional[str] = None,
+        method: typing.Optional[str] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+    ) -> None:
+        """Route.continue_
 
-        Returns the event data value.
-        Waits for event to fire and passes its value into the predicate function. Resolves when the predicate returns truthy
-        value. Will throw an error if the webSocket is closed before the event is fired.
+        Sends route's request to the network with optional overrides.
 
-        Parameters
-        ----------
-        event : str
-            Event name, same one would pass into `webSocket.on(event)`.
+        **Usage**
 
-        Returns
-        -------
-        Any
-        """
+        ```py
+        async def handle(route, request):
+            # override headers
+            headers = {
+                **request.headers,
+                \"foo\": \"foo-value\", # set \"foo\" header
+                \"bar\": None # remove \"bar\" header
+            }
+            await route.continue_(headers=headers)
 
-        try:
-            log_api("=> web_socket.wait_for_event started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.waitForEvent(
-                    event=event,
-                    predicate=self._wrap_handler(predicate),
-                    timeout=timeout,
-                )
-            )
-            log_api("<= web_socket.wait_for_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= web_socket.wait_for_event failed")
-            raise e
+        await page.route(\"**/*\", handle)
+        ```
 
-    def expect_event(
-        self,
-        event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager:
-        """WebSocket.expect_event
+        **Details**
+
+        The `headers` option applies to both the routed request and any redirects it initiates. However, `url`, `method`,
+        and `postData` only apply to the original request and are not carried over to redirected requests.
+
+        `route.continue_()` will immediately send the request to the network, other matching handlers won't be
+        invoked. Use `route.fallback()` If you want next matching handler in the chain to be invoked.
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        **NOTE** Some request headers are **forbidden** and cannot be overridden (for example, `Cookie`, `Host`,
+        `Content-Length` and others, see
+        [this MDN page](https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_request_header) for full list). If an
+        override is provided for a forbidden header, it will be ignored and the original request header will be used.
 
-        async with page.expect_event() as event_info:
-            await page.click("button")
-        value = event_info.value
+        To set custom cookies, use `browser_context.add_cookies()`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        url : Union[str, None]
+            If set changes the request URL. New URL must have same protocol as original one.
+        method : Union[str, None]
+            If set changes the request method (e.g. GET or POST).
+        headers : Union[Dict[str, str], None]
+            If set changes the request HTTP headers. Header values will be converted to a string.
+        post_data : Union[Any, bytes, str, None]
+            If set changes the post data of request.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.continue_(
+                url=url,
+                method=method,
+                headers=mapping.to_impl(headers),
+                postData=mapping.to_impl(post_data),
+            )
+        )
+
+
+mapping.register(RouteImpl, Route)
+
+
+class WebSocket(AsyncBase):
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[["WebSocket"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Fired when the websocket closes."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["framereceived"],
+        f: typing.Callable[
+            ["typing.Union[bytes, str]"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Fired when the websocket receives a frame."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["framesent"],
+        f: typing.Callable[
+            ["typing.Union[bytes, str]"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Fired when the websocket sends a frame."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["socketerror"],
+        f: typing.Callable[["str"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Fired when the websocket has an error."""
+
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[["WebSocket"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Fired when the websocket closes."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["framereceived"],
+        f: typing.Callable[
+            ["typing.Union[bytes, str]"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Fired when the websocket receives a frame."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["framesent"],
+        f: typing.Callable[
+            ["typing.Union[bytes, str]"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Fired when the websocket sends a frame."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["socketerror"],
+        f: typing.Callable[["str"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Fired when the websocket has an error."""
+
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def url(self) -> str:
+        """WebSocket.url
+
+        Contains the URL of the WebSocket.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["WebSocket"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framereceived"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["typing.Union[bytes, str]"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framesent"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["typing.Union[bytes, str]"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["socketerror"],
+        predicate: typing.Optional[typing.Callable[["str"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["str"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager[typing.Any]: ...
+
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager:
+        """WebSocket.expect_event
+
+        Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+        value. Will throw an error if the webSocket is closed before the event is fired. Returns the event data value.
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one would pass into `webSocket.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager
         """
+
         return AsyncEventContextManager(
-            self._impl_obj.waitForEvent(event, predicate, timeout)
+            self._impl_obj.expect_event(
+                event=event,
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebSocket": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["framereceived"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "typing.Union[bytes, str]": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["framesent"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "typing.Union[bytes, str]": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["socketerror"],
+        predicate: typing.Optional[typing.Callable[["str"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "str": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
+
+    async def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Any:
+        """WebSocket.wait_for_event
+
+        **NOTE** In most cases, you should use `web_socket.expect_event()`.
+
+        Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function
+        and waits for `predicate(event)` to return a truthy value. Will throw an error if the socket is closed before the
+        `event` is fired.
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for_event(
+                event=event,
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            )
         )
 
     def is_closed(self) -> bool:
@@ -663,41 +1305,197 @@ def is_closed(self) -> bool:
         bool
         """
 
-        try:
-            log_api("=> web_socket.is_closed started")
-            result = mapping.from_maybe_impl(self._impl_obj.isClosed())
-            log_api("<= web_socket.is_closed succeded")
-            return result
-        except Exception as e:
-            log_api("<= web_socket.is_closed failed")
-            raise e
+        return mapping.from_maybe_impl(self._impl_obj.is_closed())
 
 
 mapping.register(WebSocketImpl, WebSocket)
 
 
+class WebSocketRoute(AsyncBase):
+
+    @property
+    def url(self) -> str:
+        """WebSocketRoute.url
+
+        URL of the WebSocket created in the page.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    @property
+    def protocols(self) -> typing.List[str]:
+        """WebSocketRoute.protocols
+
+        The list of WebSocket subprotocols requested by the page, as passed via the second argument to the
+        [`WebSocket` constructor](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/WebSocket). Corresponds to the
+        `Sec-WebSocket-Protocol` request header.
+
+        Returns an empty array if no protocols were specified.
+
+        **Usage**
+
+        ```py
+        async def handler(ws: WebSocketRoute):
+          if \"chat.v2\" in ws.protocols:
+            ws.on_message(lambda message: ws.send(f\"v2:{message}\"))
+          else:
+            await ws.close(code=1002, reason=\"Unsupported protocol\")
+
+        await page.route_web_socket(\"wss://example.com/ws\", handler)
+        ```
+
+        Returns
+        -------
+        List[str]
+        """
+        return mapping.from_maybe_impl(self._impl_obj.protocols)
+
+    async def close(
+        self, *, code: typing.Optional[int] = None, reason: typing.Optional[str] = None
+    ) -> None:
+        """WebSocketRoute.close
+
+        Closes one side of the WebSocket connection.
+
+        Parameters
+        ----------
+        code : Union[int, None]
+            Optional [close code](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#code).
+        reason : Union[str, None]
+            Optional [close reason](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#reason).
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.close(code=code, reason=reason)
+        )
+
+    def connect_to_server(self) -> "WebSocketRoute":
+        """WebSocketRoute.connect_to_server
+
+        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` 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
+          `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 `web_socket_route.on_message()` is
+          called on the original `WebSocketRoute`.
+
+        See examples at the top for more details.
+
+        Returns
+        -------
+        WebSocketRoute
+        """
+
+        return mapping.from_impl(self._impl_obj.connect_to_server())
+
+    def send(self, message: typing.Union[str, bytes]) -> None:
+        """WebSocketRoute.send
+
+        Sends a message to the WebSocket. When called on the original WebSocket, sends the message to the page. When called
+        on the result of `web_socket_route.connect_to_server()`, sends the message to the server. See examples at the
+        top for more details.
+
+        Parameters
+        ----------
+        message : Union[bytes, str]
+            Message to send.
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.send(message=message))
+
+    def on_message(
+        self, handler: typing.Callable[[typing.Union[str, bytes]], typing.Any]
+    ) -> None:
+        """WebSocketRoute.on_message
+
+        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 `web_socket_route.send()`, forwarding them to the server-side connection
+        returned by `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 `web_socket_route.send()`. See examples at the top for more details.
+
+        Calling this method again will override the handler with a new one.
+
+        Parameters
+        ----------
+        handler : Callable[[Union[bytes, str]], Any]
+            Function that will handle messages.
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.on_message(handler=self._wrap_handler(handler))
+        )
+
+    def on_close(
+        self,
+        handler: typing.Callable[
+            [typing.Optional[int], typing.Optional[str]], typing.Any
+        ],
+    ) -> None:
+        """WebSocketRoute.on_close
+
+        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 `web_socket_route.on_close()` handler is set up, the default forwarding of closure is disabled,
+        and handler should take care of it.
+
+        Parameters
+        ----------
+        handler : Callable[[Union[int, None], Union[str, None]], Any]
+            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).
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.on_close(handler=self._wrap_handler(handler))
+        )
+
+
+mapping.register(WebSocketRouteImpl, WebSocketRoute)
+
+
 class Keyboard(AsyncBase):
-    def __init__(self, obj: KeyboardImpl):
-        super().__init__(obj)
 
-    async def down(self, key: str) -> NoneType:
+    async def down(self, key: str) -> None:
         """Keyboard.down
 
         Dispatches a `keydown` event.
-        `key` can specify the intended keyboardEvent.key
-        value or a single character to generate the text for. A superset of the `key` values can be found
-        here. Examples of the keys are:
+
+        `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` 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 suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        `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` in the upper case.
+
         If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective
         texts.
-        If `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).
-        After the key is pressed once, subsequent calls to keyboard.down(key) will have
-        repeat set to true. To release the key, use
-        keyboard.up(key).
+
+        If `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()`.
+
+        After the key is pressed once, subsequent calls to `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()`.
 
         **NOTE** Modifier keys DO influence `keyboard.down`. Holding down `Shift` will type the text in upper case.
 
@@ -707,16 +1505,9 @@ async def down(self, key: str) -> NoneType:
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
         """
 
-        try:
-            log_api("=> keyboard.down started")
-            result = mapping.from_maybe_impl(await self._impl_obj.down(key=key))
-            log_api("<= keyboard.down succeded")
-            return result
-        except Exception as e:
-            log_api("<= keyboard.down failed")
-            raise e
-
-    async def up(self, key: str) -> NoneType:
+        return mapping.from_maybe_impl(await self._impl_obj.down(key=key))
+
+    async def up(self, key: str) -> None:
         """Keyboard.up
 
         Dispatches a `keyup` event.
@@ -727,21 +1518,21 @@ async def up(self, key: str) -> NoneType:
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
         """
 
-        try:
-            log_api("=> keyboard.up started")
-            result = mapping.from_maybe_impl(await self._impl_obj.up(key=key))
-            log_api("<= keyboard.up succeded")
-            return result
-        except Exception as e:
-            log_api("<= keyboard.up failed")
-            raise e
-
-    async def insert_text(self, text: str) -> NoneType:
+        return mapping.from_maybe_impl(await self._impl_obj.up(key=key))
+
+    async def insert_text(self, text: str) -> None:
         """Keyboard.insert_text
 
         Dispatches only `input` event, does not emit the `keydown`, `keyup` or `keypress` events.
 
-        **NOTE** Modifier keys DO NOT effect `keyboard.insert_text`. Holding down `Shift` will not type the text in upper case.
+        **Usage**
+
+        ```py
+        await page.keyboard.insert_text(\"嗨\")
+        ```
+
+        **NOTE** Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper
+        case.
 
         Parameters
         ----------
@@ -749,86 +1540,101 @@ async def insert_text(self, text: str) -> NoneType:
             Sets input to the specified text value.
         """
 
-        try:
-            log_api("=> keyboard.insert_text started")
-            result = mapping.from_maybe_impl(await self._impl_obj.insertText(text=text))
-            log_api("<= keyboard.insert_text succeded")
-            return result
-        except Exception as e:
-            log_api("<= keyboard.insert_text failed")
-            raise e
-
-    async def type(self, text: str, delay: int = None) -> NoneType:
+        return mapping.from_maybe_impl(await self._impl_obj.insert_text(text=text))
+
+    async def type(self, text: str, *, delay: typing.Optional[float] = None) -> None:
         """Keyboard.type
 
+        **NOTE** In most cases, you should use `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.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]).
+
+        To press a special key, like `Control` or `ArrowDown`, use `keyboard.press()`.
+
+        **Usage**
+
+        ```py
+        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.
+
         Parameters
         ----------
         text : str
             A text to type into a focused element.
-        delay : Optional[int]
+        delay : Union[float, None]
             Time to wait between key presses in milliseconds. Defaults to 0.
         """
 
-        try:
-            log_api("=> keyboard.type started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.type(text=text, delay=delay)
-            )
-            log_api("<= keyboard.type succeded")
-            return result
-        except Exception as e:
-            log_api("<= keyboard.type failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.type(text=text, delay=delay)
+        )
 
-    async def press(self, key: str, delay: int = None) -> NoneType:
+    async def press(self, key: str, *, delay: typing.Optional[float] = None) -> None:
         """Keyboard.press
 
-        `key` can specify the intended keyboardEvent.key
-        value or a single character to generate the text for. A superset of the `key` values can be found
-        here. Examples of the keys are:
+        **NOTE** In most cases, you should use `locator.press()` instead.
+
+        `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` 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 suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        `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` in the upper case.
+
         If `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"` or `key: "Control+Shift+T"` are supported as well. When speficied with the
-        modifier, modifier is pressed and being held while the subsequent key is being pressed.
-        Shortcut for keyboard.down(key) and keyboard.up(key).
+
+        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**
+
+        ```py
+        page = await browser.new_page()
+        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=\"arrow_left.png\")
+        await page.keyboard.press(\"Shift+O\")
+        await page.screenshot(path=\"o.png\")
+        await browser.close()
+        ```
+
+        Shortcut for `keyboard.down()` and `keyboard.up()`.
 
         Parameters
         ----------
         key : str
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
-        delay : Optional[int]
+        delay : Union[float, None]
             Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
         """
 
-        try:
-            log_api("=> keyboard.press started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.press(key=key, delay=delay)
-            )
-            log_api("<= keyboard.press succeded")
-            return result
-        except Exception as e:
-            log_api("<= keyboard.press failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.press(key=key, delay=delay))
 
 
 mapping.register(KeyboardImpl, Keyboard)
 
 
 class Mouse(AsyncBase):
-    def __init__(self, obj: MouseImpl):
-        super().__init__(obj)
 
-    async def move(self, x: float, y: float, steps: int = None) -> NoneType:
+    async def move(
+        self, x: float, y: float, *, steps: typing.Optional[int] = None
+    ) -> None:
         """Mouse.move
 
         Dispatches a `mousemove` event.
@@ -836,260 +1642,245 @@ async def move(self, x: float, y: float, steps: int = None) -> NoneType:
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
-        steps : Optional[int]
-            defaults to 1. Sends intermediate `mousemove` events.
+            Y coordinate relative to the main frame's viewport in CSS pixels.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
-        try:
-            log_api("=> mouse.move started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.move(x=x, y=y, steps=steps)
-            )
-            log_api("<= mouse.move succeded")
-            return result
-        except Exception as e:
-            log_api("<= mouse.move failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.move(x=x, y=y, steps=steps))
 
     async def down(
-        self, button: Literal["left", "middle", "right"] = None, click_count: int = None
-    ) -> NoneType:
+        self,
+        *,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+    ) -> None:
         """Mouse.down
 
         Dispatches a `mousedown` event.
 
         Parameters
         ----------
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
         """
 
-        try:
-            log_api("=> mouse.down started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.down(button=button, clickCount=click_count)
-            )
-            log_api("<= mouse.down succeded")
-            return result
-        except Exception as e:
-            log_api("<= mouse.down failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.down(button=button, clickCount=click_count)
+        )
 
     async def up(
-        self, button: Literal["left", "middle", "right"] = None, click_count: int = None
-    ) -> NoneType:
+        self,
+        *,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+    ) -> None:
         """Mouse.up
 
         Dispatches a `mouseup` event.
 
         Parameters
         ----------
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
         """
 
-        try:
-            log_api("=> mouse.up started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.up(button=button, clickCount=click_count)
-            )
-            log_api("<= mouse.up succeded")
-            return result
-        except Exception as e:
-            log_api("<= mouse.up failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.up(button=button, clickCount=click_count)
+        )
 
     async def click(
         self,
         x: float,
         y: float,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        click_count: int = None,
-    ) -> NoneType:
+        *,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+    ) -> None:
         """Mouse.click
 
-        Shortcut for mouse.move(x, y[, options]), mouse.down([options]), mouse.up([options]).
+        Shortcut for `mouse.move()`, `mouse.down()`, `mouse.up()`.
 
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
-        delay : Optional[int]
+            Y coordinate relative to the main frame's viewport in CSS pixels.
+        delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
         """
 
-        try:
-            log_api("=> mouse.click started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.click(
-                    x=x, y=y, delay=delay, button=button, clickCount=click_count
-                )
-            )
-            log_api("<= mouse.click succeded")
-            return result
-        except Exception as e:
-            log_api("<= mouse.click failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.click(
+                x=x, y=y, delay=delay, button=button, clickCount=click_count
+            )
+        )
 
     async def dblclick(
         self,
         x: float,
         y: float,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-    ) -> NoneType:
+        *,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+    ) -> None:
         """Mouse.dblclick
 
-        Shortcut for mouse.move(x, y[, options]), mouse.down([options]), mouse.up([options]), mouse.down([options]) and mouse.up([options]).
+        Shortcut for `mouse.move()`, `mouse.down()`, `mouse.up()`, `mouse.down()` and
+        `mouse.up()`.
 
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
-        delay : Optional[int]
+            Y coordinate relative to the main frame's viewport in CSS pixels.
+        delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
         """
 
-        try:
-            log_api("=> mouse.dblclick started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.dblclick(x=x, y=y, delay=delay, button=button)
-            )
-            log_api("<= mouse.dblclick succeded")
-            return result
-        except Exception as e:
-            log_api("<= mouse.dblclick failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.dblclick(x=x, y=y, delay=delay, button=button)
+        )
 
+    async def wheel(self, delta_x: float, delta_y: float) -> None:
+        """Mouse.wheel
 
-mapping.register(MouseImpl, Mouse)
+        Dispatches a `wheel` event. This method is usually used to manually scroll the page. See
+        [scrolling](https://playwright.dev/python/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.
+
+        Parameters
+        ----------
+        delta_x : float
+            Pixels to scroll horizontally.
+        delta_y : float
+            Pixels to scroll vertically.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wheel(deltaX=delta_x, deltaY=delta_y)
+        )
+
+
+mapping.register(MouseImpl, Mouse)
 
 
 class Touchscreen(AsyncBase):
-    def __init__(self, obj: TouchscreenImpl):
-        super().__init__(obj)
 
-    async def tap(self, x: float, y: float) -> NoneType:
+    async def tap(self, x: float, y: float) -> None:
         """Touchscreen.tap
 
         Dispatches a `touchstart` and `touchend` event with a single touch at the position (`x`,`y`).
 
+        **NOTE** `page.tap()` the method will throw if `hasTouch` option of the browser context is false.
+
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
+            Y coordinate relative to the main frame's viewport in CSS pixels.
         """
 
-        try:
-            log_api("=> touchscreen.tap started")
-            result = mapping.from_maybe_impl(await self._impl_obj.tap(x=x, y=y))
-            log_api("<= touchscreen.tap succeded")
-            return result
-        except Exception as e:
-            log_api("<= touchscreen.tap failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.tap(x=x, y=y))
 
 
 mapping.register(TouchscreenImpl, Touchscreen)
 
 
 class JSHandle(AsyncBase):
-    def __init__(self, obj: JSHandleImpl):
-        super().__init__(obj)
 
     async def evaluate(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
+        self, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> typing.Any:
         """JSHandle.evaluate
 
-        Returns the return value of `pageFunction`
-        This method passes this handle as the first argument to `pageFunction`.
-        If `pageFunction` returns a Promise, then `handle.evaluate` would wait for the promise to resolve and return its
+        Returns the return value of `expression`.
+
+        This method passes this handle as the first argument to `expression`.
+
+        If `expression` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its
         value.
-        Examples:
+
+        **Usage**
+
+        ```py
+        tweet_handle = await page.query_selector(\".tweet .retweets\")
+        assert await tweet_handle.evaluate(\"node => node.innerText\") == \"10 retweets\"
+        ```
 
         Parameters
         ----------
         expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         Any
         """
 
-        try:
-            log_api("=> js_handle.evaluate started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.evaluate(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= js_handle.evaluate succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.evaluate failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.evaluate(
+                expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
 
     async def evaluate_handle(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
+        self, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> "JSHandle":
         """JSHandle.evaluate_handle
 
-        Returns the return value of `pageFunction` as in-page object (JSHandle).
-        This method passes this handle as the first argument to `pageFunction`.
-        The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle` returns
-        in-page object (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.evaluate_handle(pageFunction[, arg]) for more details.
+        Returns the return value of `expression` as a `JSHandle`.
+
+        This method passes this handle as the first argument to `expression`.
+
+        The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle`
+        returns `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.evaluate_handle()` for more details.
 
         Parameters
         ----------
         expression : str
-            Function to be evaluated
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         JSHandle
         """
 
-        try:
-            log_api("=> js_handle.evaluate_handle started")
-            result = mapping.from_impl(
-                await self._impl_obj.evaluateHandle(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= js_handle.evaluate_handle succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.evaluate_handle failed")
-            raise e
+        return mapping.from_impl(
+            await self._impl_obj.evaluate_handle(
+                expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
 
     async def get_property(self, property_name: str) -> "JSHandle":
         """JSHandle.get_property
@@ -1106,177 +1897,110 @@ async def get_property(self, property_name: str) -> "JSHandle":
         JSHandle
         """
 
-        try:
-            log_api("=> js_handle.get_property started")
-            result = mapping.from_impl(
-                await self._impl_obj.getProperty(propertyName=property_name)
-            )
-            log_api("<= js_handle.get_property succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.get_property failed")
-            raise e
+        return mapping.from_impl(
+            await self._impl_obj.get_property(propertyName=property_name)
+        )
 
     async def get_properties(self) -> typing.Dict[str, "JSHandle"]:
         """JSHandle.get_properties
 
         The method returns a map with **own property names** as keys and JSHandle instances for the property values.
 
+        **Usage**
+
+        ```py
+        handle = await page.evaluate_handle(\"({ window, document })\")
+        properties = await handle.get_properties()
+        window_handle = properties.get(\"window\")
+        document_handle = properties.get(\"document\")
+        await handle.dispose()
+        ```
+
         Returns
         -------
         Dict[str, JSHandle]
         """
 
-        try:
-            log_api("=> js_handle.get_properties started")
-            result = mapping.from_impl_dict(await self._impl_obj.getProperties())
-            log_api("<= js_handle.get_properties succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.get_properties failed")
-            raise e
-
-    def as_element(self) -> typing.Union["ElementHandle", NoneType]:
+        return mapping.from_impl_dict(await self._impl_obj.get_properties())
+
+    def as_element(self) -> typing.Optional["ElementHandle"]:
         """JSHandle.as_element
 
-        Returns either `null` or the object handle itself, if the object handle is an instance of ElementHandle.
+        Returns either `null` or the object handle itself, if the object handle is an instance of `ElementHandle`.
 
         Returns
         -------
-        Optional[ElementHandle]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> js_handle.as_element started")
-            result = mapping.from_impl_nullable(self._impl_obj.asElement())
-            log_api("<= js_handle.as_element succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.as_element failed")
-            raise e
-
-    async def dispose(self) -> NoneType:
+        return mapping.from_impl_nullable(self._impl_obj.as_element())
+
+    async def dispose(self) -> None:
         """JSHandle.dispose
 
         The `jsHandle.dispose` method stops referencing the element handle.
         """
 
-        try:
-            log_api("=> js_handle.dispose started")
-            result = mapping.from_maybe_impl(await self._impl_obj.dispose())
-            log_api("<= js_handle.dispose succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.dispose failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.dispose())
 
     async def json_value(self) -> typing.Any:
         """JSHandle.json_value
 
-        Returns a JSON representation of the object. If the object has a
-        `toJSON`
-        function, it **will not be called**.
+        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.
+        **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.
 
         Returns
         -------
         Any
         """
 
-        try:
-            log_api("=> js_handle.json_value started")
-            result = mapping.from_maybe_impl(await self._impl_obj.jsonValue())
-            log_api("<= js_handle.json_value succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.json_value failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.json_value())
 
 
 mapping.register(JSHandleImpl, JSHandle)
 
 
 class ElementHandle(JSHandle):
-    def __init__(self, obj: ElementHandleImpl):
-        super().__init__(obj)
-
-    def to_string(self) -> str:
-        """ElementHandle.to_string
 
-        Returns
-        -------
-        str
-        """
-
-        try:
-            log_api("=> element_handle.to_string started")
-            result = mapping.from_maybe_impl(self._impl_obj.toString())
-            log_api("<= element_handle.to_string succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.to_string failed")
-            raise e
-
-    def as_element(self) -> typing.Union["ElementHandle", NoneType]:
+    def as_element(self) -> typing.Optional["ElementHandle"]:
         """ElementHandle.as_element
 
-        Returns either `null` or the object handle itself, if the object handle is an instance of ElementHandle.
+        Returns either `null` or the object handle itself, if the object handle is an instance of `ElementHandle`.
 
         Returns
         -------
-        Optional[ElementHandle]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> element_handle.as_element started")
-            result = mapping.from_impl_nullable(self._impl_obj.asElement())
-            log_api("<= element_handle.as_element succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.as_element failed")
-            raise e
-
-    async def owner_frame(self) -> typing.Union["Frame", NoneType]:
+        return mapping.from_impl_nullable(self._impl_obj.as_element())
+
+    async def owner_frame(self) -> typing.Optional["Frame"]:
         """ElementHandle.owner_frame
 
         Returns the frame containing the given element.
 
         Returns
         -------
-        Optional[Frame]
+        Union[Frame, None]
         """
 
-        try:
-            log_api("=> element_handle.owner_frame started")
-            result = mapping.from_impl_nullable(await self._impl_obj.ownerFrame())
-            log_api("<= element_handle.owner_frame succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.owner_frame failed")
-            raise e
-
-    async def content_frame(self) -> typing.Union["Frame", NoneType]:
+        return mapping.from_impl_nullable(await self._impl_obj.owner_frame())
+
+    async def content_frame(self) -> typing.Optional["Frame"]:
         """ElementHandle.content_frame
 
         Returns the content frame for element handles referencing iframe nodes, or `null` otherwise
 
         Returns
         -------
-        Optional[Frame]
+        Union[Frame, None]
         """
 
-        try:
-            log_api("=> element_handle.content_frame started")
-            result = mapping.from_impl_nullable(await self._impl_obj.contentFrame())
-            log_api("<= element_handle.content_frame succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.content_frame failed")
-            raise e
-
-    async def get_attribute(self, name: str) -> typing.Union[str, NoneType]:
+        return mapping.from_impl_nullable(await self._impl_obj.content_frame())
+
+    async def get_attribute(self, name: str) -> typing.Optional[str]:
         """ElementHandle.get_attribute
 
         Returns element attribute value.
@@ -1288,38 +2012,22 @@ async def get_attribute(self, name: str) -> typing.Union[str, NoneType]:
 
         Returns
         -------
-        Optional[str]
+        Union[str, None]
         """
 
-        try:
-            log_api("=> element_handle.get_attribute started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.getAttribute(name=name)
-            )
-            log_api("<= element_handle.get_attribute succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.get_attribute failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.get_attribute(name=name))
 
-    async def text_content(self) -> typing.Union[str, NoneType]:
+    async def text_content(self) -> typing.Optional[str]:
         """ElementHandle.text_content
 
         Returns the `node.textContent`.
 
         Returns
         -------
-        Optional[str]
+        Union[str, None]
         """
 
-        try:
-            log_api("=> element_handle.text_content started")
-            result = mapping.from_maybe_impl(await self._impl_obj.textContent())
-            log_api("<= element_handle.text_content succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.text_content failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.text_content())
 
     async def inner_text(self) -> str:
         """ElementHandle.inner_text
@@ -1331,14 +2039,7 @@ async def inner_text(self) -> str:
         str
         """
 
-        try:
-            log_api("=> element_handle.inner_text started")
-            result = mapping.from_maybe_impl(await self._impl_obj.innerText())
-            log_api("<= element_handle.inner_text succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.inner_text failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.inner_text())
 
     async def inner_html(self) -> str:
         """ElementHandle.inner_html
@@ -1350,1018 +2051,1271 @@ async def inner_html(self) -> str:
         str
         """
 
-        try:
-            log_api("=> element_handle.inner_html started")
-            result = mapping.from_maybe_impl(await self._impl_obj.innerHTML())
-            log_api("<= element_handle.inner_html succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.inner_html failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.inner_html())
+
+    async def is_checked(self) -> bool:
+        """ElementHandle.is_checked
+
+        Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.is_checked())
+
+    async def is_disabled(self) -> bool:
+        """ElementHandle.is_disabled
+
+        Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability#enabled).
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.is_disabled())
+
+    async def is_editable(self) -> bool:
+        """ElementHandle.is_editable
+
+        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.is_editable())
+
+    async def is_enabled(self) -> bool:
+        """ElementHandle.is_enabled
+
+        Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.is_enabled())
+
+    async def is_hidden(self) -> bool:
+        """ElementHandle.is_hidden
+
+        Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability#visible).
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.is_hidden())
+
+    async def is_visible(self) -> bool:
+        """ElementHandle.is_visible
+
+        Returns whether the element is [visible](https://playwright.dev/python/docs/actionability#visible).
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.is_visible())
 
     async def dispatch_event(
-        self, type: str, event_init: typing.Dict = None
-    ) -> NoneType:
+        self, type: str, event_init: typing.Optional[typing.Dict] = None
+    ) -> None:
         """ElementHandle.dispatch_event
 
-        The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the elment, `click`
-        is dispatched. This is equivalend to calling
-        element.click().
-        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
-        and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
-        Since `eventInit` is event-specific, please refer to the events documentation for the lists of initial properties:
+        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**
+
+        ```py
+        await element_handle.dispatch_event(\"click\")
+        ```
+
+        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit`
+        properties and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
 
-        DragEvent
-        FocusEvent
-        KeyboardEvent
-        MouseEvent
-        PointerEvent
-        TouchEvent
-        Event
+        Since `eventInit` 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:
 
+        ```py
+        # note you can only create data_transfer in chromium and firefox
+        data_transfer = await page.evaluate_handle(\"new DataTransfer()\")
+        await element_handle.dispatch_event(\"#source\", \"dragstart\", {\"dataTransfer\": data_transfer})
+        ```
+
         Parameters
         ----------
         type : str
             DOM event type: `"click"`, `"dragstart"`, etc.
-        event_init : Optional[Dict]
+        event_init : Union[Dict, None]
             Optional event-specific initialization properties.
         """
 
-        try:
-            log_api("=> element_handle.dispatch_event started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.dispatchEvent(
-                    type=type, eventInit=mapping.to_impl(event_init)
-                )
-            )
-            log_api("<= element_handle.dispatch_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.dispatch_event failed")
-            raise e
-
-    async def scroll_into_view_if_needed(self, timeout: int = None) -> NoneType:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.dispatch_event(
+                type=type, eventInit=mapping.to_impl(event_init)
+            )
+        )
+
+    async def scroll_into_view_if_needed(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
         """ElementHandle.scroll_into_view_if_needed
 
-        This method waits for actionability checks, then tries to scroll element into view, unless it is
-        completely visible as defined by
-        IntersectionObserver's `ratio`.
+        This method waits for [actionability](https://playwright.dev/python/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 to a Document or a ShadowRoot.
+        [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.
+
+        See [scrolling](https://playwright.dev/python/docs/input#scrolling) for alternative ways to scroll.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
         """
 
-        try:
-            log_api("=> element_handle.scroll_into_view_if_needed started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.scrollIntoViewIfNeeded(timeout=timeout)
+        return mapping.from_maybe_impl(
+            await self._impl_obj.scroll_into_view_if_needed(
+                timeout=to_milliseconds(timeout)
             )
-            log_api("<= element_handle.scroll_into_view_if_needed succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.scroll_into_view_if_needed failed")
-            raise e
+        )
 
     async def hover(
         self,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-    ) -> NoneType:
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.hover
 
         This method hovers over the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to hover over the center of the element, or the specified `position`.
 
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.mouse to hover over the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
         Parameters
         ----------
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        """
-
-        try:
-            log_api("=> element_handle.hover started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.hover(
-                    modifiers=modifiers, position=position, timeout=timeout, force=force
-                )
-            )
-            log_api("<= element_handle.hover succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.hover failed")
-            raise e
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.hover(
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                force=force,
+                trial=trial,
+            )
+        )
 
     async def click(
         self,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        click_count: int = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
         """ElementHandle.click
 
         This method clicks the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to click in the center of the element, or the specified `position`.
+        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
         Parameters
         ----------
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.click started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.click(
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    clickCount=click_count,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= element_handle.click succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.click failed")
-            raise e
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.click(
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                delay=delay,
+                button=button,
+                clickCount=click_count,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+                steps=steps,
+            )
+        )
 
     async def dblclick(
         self,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
         """ElementHandle.dblclick
 
         This method double clicks the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to double click in the center of the element, or the specified `position`.
 
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.mouse to double click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if the first click of the `dblclick()` triggers a navigation event, this method will reject.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
-        **NOTE** `element_handle.dblclick()` dispatches two `click` events and a single `dblclick` event.
+        **NOTE** `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.
 
         Parameters
         ----------
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.dblclick started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.dblclick(
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= element_handle.dblclick succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.dblclick failed")
-            raise e
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.dblclick(
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                delay=delay,
+                button=button,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+                steps=steps,
+            )
+        )
 
     async def select_option(
         self,
-        value: typing.Union[str, typing.List[str]] = None,
-        index: typing.Union[int, typing.List[int]] = None,
-        label: typing.Union[str, typing.List[str]] = None,
-        element: typing.Union["ElementHandle", typing.List["ElementHandle"]] = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
+        value: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        *,
+        index: typing.Optional[typing.Union[int, typing.Sequence[int]]] = None,
+        label: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        element: typing.Optional[
+            typing.Union["ElementHandle", typing.Sequence["ElementHandle"]]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
     ) -> typing.List[str]:
         """ElementHandle.select_option
 
+        This method waits for [actionability](https://playwright.dev/python/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. If element is not a `<select>`
-        element, the method throws an error.
+
+        Triggers a `change` and `input` event once all the provided options have been selected.
+
+        **Usage**
+
+        ```py
+        # Single selection matching the value or label
+        await handle.select_option(\"blue\")
+        # single selection matching the label
+        await handle.select_option(label=\"blue\")
+        # multiple selection
+        await handle.select_option(value=[\"red\", \"green\", \"blue\"])
+        ```
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
+        value : Union[Sequence[str], str, None]
+            Options to select by value. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        index : Union[Sequence[int], int, None]
+            Options to select by index. Optional.
+        label : Union[Sequence[str], str, None]
+            Options to select by label. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        element : Union[ElementHandle, Sequence[ElementHandle], None]
+            Option elements to select. Optional.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
 
         Returns
         -------
         List[str]
         """
 
-        try:
-            log_api("=> element_handle.select_option started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.selectOption(
-                    value=value,
-                    index=index,
-                    label=label,
-                    element=mapping.to_impl(element),
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= element_handle.select_option succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.select_option failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.select_option(
+                value=mapping.to_impl(value),
+                index=mapping.to_impl(index),
+                label=mapping.to_impl(label),
+                element=mapping.to_impl(element),
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+            )
+        )
 
     async def tap(
         self,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.tap
 
         This method taps the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.touchscreen` to tap the center of the element, or the specified `position`.
 
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.touchscreen to tap in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
-        **NOTE** `element_handle.tap()` requires that the `hasTouch` option of the browser context be set to true.
+        **NOTE** `elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.
 
         Parameters
         ----------
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.tap started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.tap(
-                    modifiers=modifiers,
-                    position=position,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= element_handle.tap succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.tap failed")
-            raise e
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.tap(
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+            )
+        )
 
     async def fill(
-        self, value: str, timeout: int = None, no_wait_after: bool = None
-    ) -> NoneType:
+        self,
+        value: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.fill
 
-        This method waits for actionability checks, focuses the element, fills it and triggers an `input`
-        event after filling. If the element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws
-        an error. Note that you can pass an empty string to clear the input field.
+        This method waits for [actionability](https://playwright.dev/python/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.press_sequentially()`.
 
         Parameters
         ----------
         value : str
             Value to set for the `<input>`, `<textarea>` or `[contenteditable]` element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.fill(
+                value=value,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                force=force,
+            )
+        )
 
-        try:
-            log_api("=> element_handle.fill started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.fill(
-                    value=value, timeout=timeout, noWaitAfter=no_wait_after
-                )
-            )
-            log_api("<= element_handle.fill succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.fill failed")
-            raise e
-
-    async def select_text(self, timeout: int = None) -> NoneType:
+    async def select_text(
+        self,
+        *,
+        force: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
         """ElementHandle.select_text
 
-        This method waits for actionability checks, then focuses the element and selects all its text
-        content.
+        This method waits for [actionability](https://playwright.dev/python/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.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
         """
 
-        try:
-            log_api("=> element_handle.select_text started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.selectText(timeout=timeout)
+        return mapping.from_maybe_impl(
+            await self._impl_obj.select_text(
+                force=force, timeout=to_milliseconds(timeout)
             )
-            log_api("<= element_handle.select_text succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.select_text failed")
-            raise e
+        )
+
+    async def input_value(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """ElementHandle.input_value
+
+        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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.input_value(timeout=to_milliseconds(timeout))
+        )
 
     async def set_input_files(
         self,
         files: typing.Union[
             str,
             pathlib.Path,
-            "FilePayload",
-            typing.List[str],
-            typing.List[pathlib.Path],
-            typing.List["FilePayload"],
+            FilePayload,
+            typing.Sequence[typing.Union[str, pathlib.Path]],
+            typing.Sequence[FilePayload],
         ],
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.set_input_files
 
-        This method expects `elementHandle` to point to an input
-        element.
-        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.
+        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` 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.
 
         Parameters
         ----------
-        files : Union[str, pathlib.Path, Dict, List[str], List[pathlib.Path], List[Dict]]
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        files : Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}]
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_input_files(
+                files=mapping.to_impl(files),
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+            )
+        )
 
-        try:
-            log_api("=> element_handle.set_input_files started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.setInputFiles(
-                    files=files, timeout=timeout, noWaitAfter=no_wait_after
-                )
-            )
-            log_api("<= element_handle.set_input_files succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.set_input_files failed")
-            raise e
-
-    async def focus(self) -> NoneType:
+    async def focus(self) -> None:
         """ElementHandle.focus
 
-        Calls focus on the element.
+        Calls [focus](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the element.
         """
 
-        try:
-            log_api("=> element_handle.focus started")
-            result = mapping.from_maybe_impl(await self._impl_obj.focus())
-            log_api("<= element_handle.focus succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.focus failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.focus())
 
     async def type(
         self,
         text: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.type
 
-        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 element_handle.press(key[, options]).
-        An example of typing into a text field and then submitting the form:
+        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 `element_handle.press()`.
+
+        **Usage**
 
         Parameters
         ----------
         text : str
             A text to type into a focused element.
-        delay : Optional[int]
+        delay : Union[float, None]
             Time to wait between key presses in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.type started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.type(
-                    text=text, delay=delay, timeout=timeout, noWaitAfter=no_wait_after
-                )
-            )
-            log_api("<= element_handle.type succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.type failed")
-            raise e
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.type(
+                text=text,
+                delay=delay,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+            )
+        )
 
     async def press(
         self,
         key: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.press
 
-        Focuses the element, and then uses keyboard.down(key) and keyboard.up(key).
-        `key` can specify the intended keyboardEvent.key
-        value or a single character to generate the text for. A superset of the `key` values can be found
-        here. Examples of the keys are:
+        Focuses the element, and then uses `keyboard.down()` and `keyboard.up()`.
+
+        `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` 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 suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        `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` in the upper case.
+
         If `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"` or `key: "Control+Shift+T"` are supported as well. When speficied with the
-        modifier, modifier is pressed and being held while the subsequent key is being pressed.
+
+        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.
 
         Parameters
         ----------
         key : str
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
-        delay : Optional[int]
+        delay : Union[float, None]
             Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.press(
+                key=key,
+                delay=delay,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+            )
+        )
 
-        try:
-            log_api("=> element_handle.press started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.press(
-                    key=key, delay=delay, timeout=timeout, noWaitAfter=no_wait_after
-                )
-            )
-            log_api("<= element_handle.press succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.press failed")
-            raise e
+    async def set_checked(
+        self,
+        checked: bool,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """ElementHandle.set_checked
+
+        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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        checked : bool
+            Whether to check or uncheck the checkbox.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_checked(
+                checked=checked,
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+            )
+        )
 
     async def check(
-        self, timeout: int = None, force: bool = None, no_wait_after: bool = None
-    ) -> NoneType:
+        self,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.check
 
         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/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to click in the center of the element.
+        1. Ensure that the element is now checked. If not, this method throws.
 
-        Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already checked, this method returns immediately.
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now checked. If not, this method rejects.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.check started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.check(
-                    timeout=timeout, force=force, noWaitAfter=no_wait_after
-                )
-            )
-            log_api("<= element_handle.check succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.check failed")
-            raise e
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.check(
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+            )
+        )
 
     async def uncheck(
-        self, timeout: int = None, force: bool = None, no_wait_after: bool = None
-    ) -> NoneType:
+        self,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.uncheck
 
         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/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to click in the center of the element.
+        1. Ensure that the element is now unchecked. If not, this method throws.
 
-        Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already unchecked, this method returns immediately.
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now unchecked. If not, this method rejects.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.uncheck(
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+            )
+        )
 
-        try:
-            log_api("=> element_handle.uncheck started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.uncheck(
-                    timeout=timeout, force=force, noWaitAfter=no_wait_after
-                )
-            )
-            log_api("<= element_handle.uncheck succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.uncheck failed")
-            raise e
-
-    async def bounding_box(self) -> typing.Union["FloatRect", NoneType]:
+    async def bounding_box(self) -> typing.Optional[FloatRect]:
         """ElementHandle.bounding_box
 
         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 bonding box, similarly to
-        Element.getBoundingClientRect. That
-        means `x` and/or `y` may be negative.
+
+        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.
-        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.
+        [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**
+
+        ```py
+        box = await element_handle.bounding_box()
+        await page.mouse.click(box[\"x\"] + box[\"width\"] / 2, box[\"y\"] + box[\"height\"] / 2)
+        ```
 
         Returns
         -------
-        Optional[{"x": float, "y": float, "width": float, "height": float}]
+        Union[{x: float, y: float, width: float, height: float}, None]
         """
 
-        try:
-            log_api("=> element_handle.bounding_box started")
-            result = mapping.from_impl_nullable(await self._impl_obj.boundingBox())
-            log_api("<= element_handle.bounding_box succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.bounding_box failed")
-            raise e
+        return mapping.from_impl_nullable(await self._impl_obj.bounding_box())
 
     async def screenshot(
         self,
-        timeout: int = None,
-        type: Literal["jpeg", "png"] = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        quality: int = None,
-        omit_background: bool = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        type: typing.Optional[Literal["jpeg", "png"]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+        omit_background: typing.Optional[bool] = None,
+        animations: typing.Optional[Literal["allow", "disabled"]] = None,
+        caret: typing.Optional[Literal["hide", "initial"]] = None,
+        scale: typing.Optional[Literal["css", "device"]] = None,
+        mask: typing.Optional[typing.Sequence["Locator"]] = None,
+        mask_color: typing.Optional[str] = None,
+        style: typing.Optional[str] = None,
     ) -> bytes:
         """ElementHandle.screenshot
 
+        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/python/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.
-        This method waits for the actionability checks, then scrolls element into view before taking a
-        screenshot. If the element is detached from DOM, the method throws an error.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        type : Optional[Literal['jpeg', 'png']]
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        type : Union["jpeg", "png", None]
             Specify screenshot type, defaults to `png`.
-        path : Union[str, pathlib.Path, NoneType]
-            The file path to save the image to. The screenshot type will be inferred from file extension. If `path` is a relative path, then it is resolved relative to current working directory. If no path is provided, the image won't be saved to the disk.
-        quality : Optional[int]
+        path : Union[pathlib.Path, str, None]
+            The file path to save the image to. The screenshot type will be inferred from file extension. If `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.
+        quality : Union[int, None]
             The quality of the image, between 0-100. Not applicable to `png` images.
-        omit_background : Optional[bool]
-            Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images. Defaults to `false`.
+        omit_background : Union[bool, None]
+            Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.
+            Defaults to `false`.
+        animations : Union["allow", "disabled", None]
+            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.
+        caret : Union["hide", "initial", None]
+            When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be
+            changed.  Defaults to `"hide"`.
+        scale : Union["css", "device", None]
+            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"`.
+        mask : Union[Sequence[Locator], None]
+            Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
+        mask_color : Union[str, None]
+            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`.
+        style : Union[str, None]
+            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.
 
         Returns
         -------
         bytes
         """
 
-        try:
-            log_api("=> element_handle.screenshot started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.screenshot(
-                    timeout=timeout,
-                    type=type,
-                    path=path,
-                    quality=quality,
-                    omitBackground=omit_background,
-                )
-            )
-            log_api("<= element_handle.screenshot succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.screenshot failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.screenshot(
+                timeout=to_milliseconds(timeout),
+                type=type,
+                path=path,
+                quality=quality,
+                omitBackground=omit_background,
+                animations=animations,
+                caret=caret,
+                scale=scale,
+                mask=mapping.to_impl(mask),
+                maskColor=mask_color,
+                style=style,
+            )
+        )
 
-    async def query_selector(
-        self, selector: str
-    ) -> typing.Union["ElementHandle", NoneType]:
+    async def query_selector(self, selector: str) -> typing.Optional["ElementHandle"]:
         """ElementHandle.query_selector
 
-        The method finds an element matching the specified selector in the `ElementHandle`'s subtree. See Working with
-        selectors for more details. If no elements match the selector, the return value resolves to
-        `null`.
+        The method finds an element matching the specified selector in the `ElementHandle`'s subtree. If no elements match
+        the selector, returns `null`.
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
+            A selector to query for.
 
         Returns
         -------
-        Optional[ElementHandle]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> element_handle.query_selector started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.querySelector(selector=selector)
-            )
-            log_api("<= element_handle.query_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.query_selector failed")
-            raise e
+        return mapping.from_impl_nullable(
+            await self._impl_obj.query_selector(selector=selector)
+        )
 
     async def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         """ElementHandle.query_selector_all
 
-        The method finds all elements matching the specified selector in the `ElementHandle`s subtree. See Working with
-        selectors for more details. If no elements match the selector, the return value resolves to
-        `[]`.
+        The method finds all elements matching the specified selector in the `ElementHandle`s subtree. If no elements match
+        the selector, returns empty array.
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
+            A selector to query for.
 
         Returns
         -------
         List[ElementHandle]
         """
 
-        try:
-            log_api("=> element_handle.query_selector_all started")
-            result = mapping.from_impl_list(
-                await self._impl_obj.querySelectorAll(selector=selector)
-            )
-            log_api("<= element_handle.query_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.query_selector_all failed")
-            raise e
+        return mapping.from_impl_list(
+            await self._impl_obj.query_selector_all(selector=selector)
+        )
 
     async def eval_on_selector(
-        self,
-        selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
+        self, selector: str, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> typing.Any:
         """ElementHandle.eval_on_selector
 
-        Returns the return value of `pageFunction`
-        The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a first
-        argument to `pageFunction`. See Working with selectors for more details. If no elements match
-        the selector, the method throws an error.
-        If `pageFunction` returns a Promise, then `frame.$eval` would wait for the promise to resolve and return its value.
-        Examples:
+        Returns the return value of `expression`.
+
+        The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a
+        first argument to `expression`. If no elements match the selector, the method throws an error.
+
+        If `expression` returns a [Promise], then `element_handle.eval_on_selector()` would wait for the promise to
+        resolve and return its value.
+
+        **Usage**
+
+        ```py
+        tweet_handle = await page.query_selector(\".tweet\")
+        assert await tweet_handle.eval_on_selector(\".like\", \"node => node.innerText\") == \"100\"
+        assert await tweet_handle.eval_on_selector(\".retweets\", \"node => node.innerText\") == \"10\"
+        ```
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
+            A selector to query for.
         expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         Any
         """
 
-        try:
-            log_api("=> element_handle.eval_on_selector started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.evalOnSelector(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= element_handle.eval_on_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.eval_on_selector failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.eval_on_selector(
+                selector=selector, expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
 
     async def eval_on_selector_all(
-        self,
-        selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
+        self, selector: str, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> typing.Any:
         """ElementHandle.eval_on_selector_all
 
-        Returns the return value of `pageFunction`
-        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`. See Working with selectors for more
-        details.
-        If `pageFunction` returns a Promise, then `frame.$$eval` would wait for the promise to resolve and return its value.
-        Examples:
-        ```html
-        <div class="feed">
-          <div class="tweet">Hello!</div>
-          <div class="tweet">Hi!</div>
+        Returns the return value of `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 `expression`.
+
+        If `expression` returns a [Promise], then `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>
         ```
 
+        ```py
+        feed_handle = await page.query_selector(\".feed\")
+        assert await feed_handle.eval_on_selector_all(\".tweet\", \"nodes => nodes.map(n => n.innerText)\") == [\"hello!\", \"hi!\"]
+        ```
+
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
+            A selector to query for.
         expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         Any
         """
 
-        try:
-            log_api("=> element_handle.eval_on_selector_all started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.evalOnSelectorAll(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= element_handle.eval_on_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.eval_on_selector_all failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.eval_on_selector_all(
+                selector=selector, expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
 
     async def wait_for_element_state(
         self,
-        state: Literal["disabled", "enabled", "hidden", "stable", "visible"],
-        timeout: int = None,
-    ) -> NoneType:
+        state: Literal[
+            "disabled", "editable", "enabled", "hidden", "stable", "visible"
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
         """ElementHandle.wait_for_element_state
 
-        Returns the element satisfies the `state`.
-        Depending on the `state` parameter, this method waits for one of the actionability checks to pass.
-        This method throws when the element is detached while waiting, unless waiting for the `"hidden"` state.
+        Returns when the element satisfies the `state`.
 
-        `"visible"` Wait until the element is visible.
-        `"hidden"` Wait until the element is not visible or not attached. Note that waiting for hidden does not throw when the element detaches.
-        `"stable"` Wait until the element is both visible and stable.
-        `"enabled"` Wait until the element is enabled.
-        `"disabled"` Wait until the element is not enabled.
+        Depending on the `state` parameter, this method waits for one of the [actionability](https://playwright.dev/python/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/python/docs/actionability#visible).
+        - `\"hidden\"` Wait until the element is [not visible](https://playwright.dev/python/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/python/docs/actionability#visible) and
+          [stable](https://playwright.dev/python/docs/actionability#stable).
+        - `\"enabled\"` Wait until the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
+        - `\"disabled\"` Wait until the element is [not enabled](https://playwright.dev/python/docs/actionability#enabled).
+        - `\"editable\"` Wait until the element is [editable](https://playwright.dev/python/docs/actionability#editable).
 
         If the element does not satisfy the condition for the `timeout` milliseconds, this method will throw.
 
         Parameters
         ----------
-        state : Literal['disabled', 'enabled', 'hidden', 'stable', 'visible']
+        state : Union["disabled", "editable", "enabled", "hidden", "stable", "visible"]
             A state to wait for, see below for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
         """
 
-        try:
-            log_api("=> element_handle.wait_for_element_state started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.waitForElementState(state=state, timeout=timeout)
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for_element_state(
+                state=state, timeout=to_milliseconds(timeout)
             )
-            log_api("<= element_handle.wait_for_element_state succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.wait_for_element_state failed")
-            raise e
+        )
 
     async def wait_for_selector(
         self,
         selector: str,
-        state: Literal["attached", "detached", "hidden", "visible"] = None,
-        timeout: int = None,
-    ) -> typing.Union["ElementHandle", NoneType]:
+        *,
+        state: typing.Optional[
+            Literal["attached", "detached", "hidden", "visible"]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> typing.Optional["ElementHandle"]:
         """ElementHandle.wait_for_selector
 
-        Returns element specified by selector satisfies `state` option. Resolves to `null` if waiting for `hidden` or
+        Returns element specified by selector when it satisfies `state` option. Returns `null` if waiting for `hidden` or
         `detached`.
-        Wait for the `selector` relative to the element handle to satisfy `state` option (either appear/disappear from dom, or
-        become visible/hidden). If at the moment of calling the method `selector` already satisfies the condition, the method
-        will return immediately. If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will
-        throw.
-
-        **NOTE** This method does not work across navigations, use page.wait_for_selector(selector[, options]) instead.
-
-        Parameters
-        ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-        state : Optional[Literal['attached', 'detached', 'hidden', 'visible']]
-            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.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-
-        Returns
-        -------
-        Optional[ElementHandle]
-        """
-
-        try:
-            log_api("=> element_handle.wait_for_selector started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.waitForSelector(
-                    selector=selector, state=state, timeout=timeout
-                )
-            )
-            log_api("<= element_handle.wait_for_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.wait_for_selector failed")
-            raise e
-
-
-mapping.register(ElementHandleImpl, ElementHandle)
-
 
-class Accessibility(AsyncBase):
-    def __init__(self, obj: AccessibilityImpl):
-        super().__init__(obj)
+        Wait for the `selector` relative to the element handle to satisfy `state` option (either appear/disappear from dom,
+        or become visible/hidden). If at the moment of calling the method `selector` already satisfies the condition, the
+        method will return immediately. If the selector doesn't satisfy the condition for the `timeout` milliseconds, the
+        function will throw.
 
-    async def snapshot(
-        self, interesting_only: bool = None, root: "ElementHandle" = None
-    ) -> typing.Union[typing.Dict, NoneType]:
-        """Accessibility.snapshot
+        **Usage**
 
-        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` is set to `false`.
+        ```py
+        await page.set_content(\"<div><span></span></div>\")
+        div = await page.query_selector(\"div\")
+        # waiting for the \"span\" selector relative to the div.
+        span = await div.wait_for_selector(\"span\", state=\"attached\")
+        ```
 
-        An example of dumping the entire accessibility tree:
-        An example of logging the focused node's name:
+        **NOTE** This method does not work across navigations, use `page.wait_for_selector()` instead.
 
         Parameters
         ----------
-        interesting_only : Optional[bool]
-            Prune uninteresting nodes from the tree. Defaults to `true`.
-        root : Optional[ElementHandle]
-            The root DOM element for the snapshot. Defaults to the whole page.
+        selector : str
+            A selector to query for.
+        state : Union["attached", "detached", "hidden", "visible", None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        strict : Union[bool, None]
+            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.
 
         Returns
         -------
-        Optional[Dict]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> accessibility.snapshot started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.snapshot(
-                    interestingOnly=interesting_only, root=mapping.to_impl(root)
-                )
+        return mapping.from_impl_nullable(
+            await self._impl_obj.wait_for_selector(
+                selector=selector,
+                state=state,
+                timeout=to_milliseconds(timeout),
+                strict=strict,
             )
-            log_api("<= accessibility.snapshot succeded")
-            return result
-        except Exception as e:
-            log_api("<= accessibility.snapshot failed")
-            raise e
+        )
 
 
-mapping.register(AccessibilityImpl, Accessibility)
+mapping.register(ElementHandleImpl, ElementHandle)
 
 
 class FileChooser(AsyncBase):
-    def __init__(self, obj: FileChooserImpl):
-        super().__init__(obj)
 
     @property
     def page(self) -> "Page":
@@ -2387,7 +3341,6 @@ def element(self) -> "ElementHandle":
         """
         return mapping.from_impl(self._impl_obj.element)
 
-    @property
     def is_multiple(self) -> bool:
         """FileChooser.is_multiple
 
@@ -2397,51 +3350,51 @@ def is_multiple(self) -> bool:
         -------
         bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.isMultiple)
+
+        return mapping.from_maybe_impl(self._impl_obj.is_multiple())
 
     async def set_files(
         self,
         files: typing.Union[
-            str, "FilePayload", typing.List[str], typing.List["FilePayload"]
+            str,
+            pathlib.Path,
+            FilePayload,
+            typing.Sequence[typing.Union[str, pathlib.Path]],
+            typing.Sequence[FilePayload],
         ],
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
         """FileChooser.set_files
 
-        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.
+        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.
 
         Parameters
         ----------
-        files : Union[str, Dict, List[str], List[Dict]]
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> file_chooser.set_files started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.setFiles(
-                    files=files, timeout=timeout, noWaitAfter=no_wait_after
-                )
+        files : Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}]
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_files(
+                files=mapping.to_impl(files),
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
             )
-            log_api("<= file_chooser.set_files succeded")
-            return result
-        except Exception as e:
-            log_api("<= file_chooser.set_files failed")
-            raise e
+        )
 
 
 mapping.register(FileChooserImpl, FileChooser)
 
 
 class Frame(AsyncBase):
-    def __init__(self, obj: FrameImpl):
-        super().__init__(obj)
 
     @property
     def page(self) -> "Page":
@@ -2460,6 +3413,7 @@ def name(self) -> str:
         """Frame.name
 
         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
@@ -2484,16 +3438,16 @@ def url(self) -> str:
         return mapping.from_maybe_impl(self._impl_obj.url)
 
     @property
-    def parent_frame(self) -> typing.Union["Frame", NoneType]:
+    def parent_frame(self) -> typing.Optional["Frame"]:
         """Frame.parent_frame
 
         Parent frame, if any. Detached frames and main frames return `null`.
 
         Returns
         -------
-        Optional[Frame]
+        Union[Frame, None]
         """
-        return mapping.from_impl_nullable(self._impl_obj.parentFrame)
+        return mapping.from_impl_nullable(self._impl_obj.parent_frame)
 
     @property
     def child_frames(self) -> typing.List["Frame"]:
@@ -2503,6131 +3457,19841 @@ def child_frames(self) -> typing.List["Frame"]:
         -------
         List[Frame]
         """
-        return mapping.from_impl_list(self._impl_obj.childFrames)
+        return mapping.from_impl_list(self._impl_obj.child_frames)
 
     async def goto(
         self,
         url: str,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        referer: str = None,
-    ) -> typing.Union["Response", NoneType]:
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        referer: typing.Optional[str] = None,
+    ) -> typing.Optional["Response"]:
         """Frame.goto
 
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-        last redirect.
-        `frame.goto` will throw an error if:
+        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of
+        the last redirect.
 
-        there's an SSL error (e.g. in case of self-signed certificates).
-        target URL is invalid.
-        the `timeout` is exceeded during navigation.
-        the remote server does not respond or is unreachable.
-        the main resource failed to load.
+        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` is exceeded during navigation.
+        - the remote server does not respond or is unreachable.
+        - the main resource failed to load.
 
-        `frame.goto` 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().
+        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()`.
 
-        **NOTE** `frame.goto` either throws an error or returns a main resource response. The only exceptions are navigation
+        **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.
+
+        **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).
 
         Parameters
         ----------
         url : str
             URL to navigate frame to. The url should include scheme, e.g. `https://`.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
             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'` - consider operation to be finished when there are no network connections for at least `500` ms.
-        referer : Optional[str]
-            Referer header value. If provided it will take preference over the referer header value set by page.setExtraHTTPHeaders(headers).
+            - `'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.
+        referer : Union[str, None]
+            Referer header value. If provided it will take preference over the referer header value set by
+            `page.set_extra_http_headers()`.
 
         Returns
         -------
-        Optional[Response]
+        Union[Response, None]
         """
 
-        try:
-            log_api("=> frame.goto started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.goto(
-                    url=url, timeout=timeout, waitUntil=wait_until, referer=referer
-                )
-            )
-            log_api("<= frame.goto succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.goto failed")
-            raise e
-
-    async def wait_for_navigation(
-        self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Frame.wait_for_navigation
-
-        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`.
-        This resolves when the frame navigates to a new URL. It is useful for when you run code which will indirectly cause the
-        frame to navigate. Consider this example:
-        **NOTE** Usage of the History API to change the URL is
-        considered a navigation.
-
-        Parameters
-        ----------
-        url : Union[str, Pattern, Callable[[str], bool], NoneType]
-            URL string, URL regex pattern or predicate receiving URL to match while waiting for the navigation.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
+        return mapping.from_impl_nullable(
+            await self._impl_obj.goto(
+                url=url,
+                timeout=to_milliseconds(timeout),
+                waitUntil=wait_until,
+                referer=referer,
+            )
+        )
+
+    def expect_navigation(
+        self,
+        *,
+        url: typing.Optional[
+            typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]]
+        ] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["Response"]:
+        """Frame.expect_navigation
+
+        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:
+
+        ```py
+        async with frame.expect_navigation():
+            await frame.click(\"a.delayed-navigation\") # clicking the link will indirectly cause a navigation
+        # Resolves after navigation has finished
+        ```
+
+        **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.
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str, None]
+            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.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
             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'` - consider operation to be finished when there are no network connections for at least `500` ms.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+            - `'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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
 
         Returns
         -------
-        Optional[Response]
+        EventContextManager[Response]
         """
 
-        try:
-            log_api("=> frame.wait_for_navigation started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.waitForNavigation(
-                    url=self._wrap_handler(url), waitUntil=wait_until, timeout=timeout
-                )
-            )
-            log_api("<= frame.wait_for_navigation succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.wait_for_navigation failed")
-            raise e
+        return AsyncEventContextManager(
+            self._impl_obj.expect_navigation(
+                url=self._wrap_handler(url),
+                waitUntil=wait_until,
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    async def wait_for_url(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        *,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Frame.wait_for_url
+
+        Waits for the frame to navigate to the given URL.
+
+        **Usage**
+
+        ```py
+        await frame.click(\"a.delayed-navigation\") # clicking the link will indirectly cause a navigation
+        await frame.wait_for_url(\"**/target.html\")
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            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.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for_url(
+                url=self._wrap_handler(url),
+                waitUntil=wait_until,
+                timeout=to_milliseconds(timeout),
+            )
+        )
 
     async def wait_for_load_state(
         self,
-        state: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> NoneType:
+        state: typing.Optional[
+            Literal["domcontentloaded", "load", "networkidle"]
+        ] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
         """Frame.wait_for_load_state
 
-        Returns when the required load state has been reached.
-        This resolves 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.
+        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/python/docs/actionability).
+
+        **Usage**
+
+        ```py
+        await frame.click(\"button\") # click triggers navigation.
+        await frame.wait_for_load_state() # the promise resolves after \"load\" event.
+        ```
 
         Parameters
         ----------
-        state : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            Load state to wait for, defaults to `load`. If the state has been already reached while loading current document, the method resolves immediately. Optional.
-             - `'load'` - wait for the `load` event to be fired.
-             - `'domcontentloaded'` - wait for the `DOMContentLoaded` event to be fired.
-             - `'networkidle'` - wait until there are no network connections for at least `500` ms.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        """
-
-        try:
-            log_api("=> frame.wait_for_load_state started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.waitForLoadState(state=state, timeout=timeout)
+        state : Union["domcontentloaded", "load", "networkidle", None]
+            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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for_load_state(
+                state=state, timeout=to_milliseconds(timeout)
             )
-            log_api("<= frame.wait_for_load_state succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.wait_for_load_state failed")
-            raise e
+        )
 
     async def frame_element(self) -> "ElementHandle":
         """Frame.frame_element
 
         Returns the `frame` or `iframe` element handle which corresponds to this frame.
-        This is an inverse of element_handle.content_frame(). Note that returned handle actually belongs to the parent frame.
+
+        This is an inverse of `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**
+
+        ```py
+        frame_element = await frame.frame_element()
+        content_frame = await frame_element.content_frame()
+        assert frame == content_frame
+        ```
+
         Returns
         -------
         ElementHandle
         """
 
-        try:
-            log_api("=> frame.frame_element started")
-            result = mapping.from_impl(await self._impl_obj.frameElement())
-            log_api("<= frame.frame_element succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.frame_element failed")
-            raise e
+        return mapping.from_impl(await self._impl_obj.frame_element())
 
     async def evaluate(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
+        self, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> typing.Any:
         """Frame.evaluate
 
-        Returns the return value of `pageFunction`
-        If the function passed to the `frame.evaluate` returns a Promise, then `frame.evaluate` would wait for the promise to
-        resolve and return its value.
-        If the function passed to the `frame.evaluate` returns a non-Serializable value, then `frame.evaluate` resolves to
-        `undefined`. DevTools Protocol also supports transferring some additional values that are not serializable by `JSON`:
-        `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
+        Returns the return value of `expression`.
+
+        If the function passed to the `frame.evaluate()` returns a [Promise], then `frame.evaluate()` would
+        wait for the promise to resolve and return its value.
+
+        If the function passed to the `frame.evaluate()` returns a non-[Serializable] value, then
+        `frame.evaluate()` returns `undefined`. Playwright also supports transferring some additional values that
+        are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
+
+        **Usage**
+
+        ```py
+        result = await frame.evaluate(\"([x, y]) => Promise.resolve(x * y)\", [7, 8])
+        print(result) # prints \"56\"
+        ```
+
         A string can also be passed in instead of a function.
-        ElementHandle instances can be passed as an argument to the `frame.evaluate`:
+
+        ```py
+        print(await frame.evaluate(\"1 + 2\")) # prints \"3\"
+        x = 10
+        print(await frame.evaluate(f\"1 + {x}\")) # prints \"11\"
+        ```
+
+        `ElementHandle` instances can be passed as an argument to the `frame.evaluate()`:
+
+        ```py
+        body_handle = await frame.evaluate(\"document.body\")
+        html = await frame.evaluate(\"([body, suffix]) => body.innerHTML + suffix\", [body_handle, \"hello\"])
+        await body_handle.dispose()
+        ```
 
         Parameters
         ----------
         expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         Any
         """
 
-        try:
-            log_api("=> frame.evaluate started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.evaluate(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= frame.evaluate succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.evaluate failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.evaluate(
+                expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
 
     async def evaluate_handle(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
+        self, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> "JSHandle":
         """Frame.evaluate_handle
 
-        Returns the return value of `pageFunction` as in-page object (JSHandle).
-        The only difference between `frame.evaluate` and `frame.evaluate_handle` is that `frame.evaluate_handle` returns in-page
-        object (JSHandle).
-        If the function, passed to the `frame.evaluate_handle`, returns a Promise, then `frame.evaluate_handle` would wait for
-        the promise to resolve and return its value.
+        Returns the return value of `expression` as a `JSHandle`.
+
+        The only difference between `frame.evaluate()` and `frame.evaluate_handle()` is that
+        `frame.evaluate_handle()` returns `JSHandle`.
+
+        If the function, passed to the `frame.evaluate_handle()`, returns a [Promise], then
+        `frame.evaluate_handle()` would wait for the promise to resolve and return its value.
+
+        **Usage**
+
+        ```py
+        a_window_handle = await frame.evaluate_handle(\"Promise.resolve(window)\")
+        a_window_handle # handle for the window object.
+        ```
+
         A string can also be passed in instead of a function.
-        JSHandle instances can be passed as an argument to the `frame.evaluate_handle`:
+
+        ```py
+        a_handle = await page.evaluate_handle(\"document\") # handle for the \"document\"
+        ```
+
+        `JSHandle` instances can be passed as an argument to the `frame.evaluate_handle()`:
+
+        ```py
+        a_handle = await page.evaluate_handle(\"document.body\")
+        result_handle = await page.evaluate_handle(\"body => body.innerHTML\", a_handle)
+        print(await result_handle.json_value())
+        await result_handle.dispose()
+        ```
 
         Parameters
         ----------
         expression : str
-            Function to be evaluated in the page context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         JSHandle
         """
 
-        try:
-            log_api("=> frame.evaluate_handle started")
-            result = mapping.from_impl(
-                await self._impl_obj.evaluateHandle(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= frame.evaluate_handle succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.evaluate_handle failed")
-            raise e
+        return mapping.from_impl(
+            await self._impl_obj.evaluate_handle(
+                expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
 
     async def query_selector(
-        self, selector: str
-    ) -> typing.Union["ElementHandle", NoneType]:
+        self, selector: str, *, strict: typing.Optional[bool] = None
+    ) -> typing.Optional["ElementHandle"]:
         """Frame.query_selector
 
         Returns the ElementHandle pointing to the frame element.
-        The method finds an element matching the specified selector within the frame. See Working with
-        selectors for more details. If no elements match the selector, the return value resolves to
-        `null`.
+
+        **NOTE** The use of `ElementHandle` is discouraged, use `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`.
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
+            A selector to query for.
+        strict : Union[bool, None]
+            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.
 
         Returns
         -------
-        Optional[ElementHandle]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> frame.query_selector started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.querySelector(selector=selector)
-            )
-            log_api("<= frame.query_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.query_selector failed")
-            raise e
+        return mapping.from_impl_nullable(
+            await self._impl_obj.query_selector(selector=selector, strict=strict)
+        )
 
     async def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         """Frame.query_selector_all
 
         Returns the ElementHandles pointing to the frame elements.
-        The method finds all elements matching the specified selector within the frame. See Working with
-        selectors for more details. If no elements match the selector, the return value resolves to
-        `[]`.
+
+        **NOTE** The use of `ElementHandle` is discouraged, use `Locator` objects instead.
+
+        The method finds all elements matching the specified selector within the frame. If no elements match the selector,
+        returns empty array.
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
+            A selector to query for.
 
         Returns
         -------
         List[ElementHandle]
         """
 
-        try:
-            log_api("=> frame.query_selector_all started")
-            result = mapping.from_impl_list(
-                await self._impl_obj.querySelectorAll(selector=selector)
-            )
-            log_api("<= frame.query_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.query_selector_all failed")
-            raise e
+        return mapping.from_impl_list(
+            await self._impl_obj.query_selector_all(selector=selector)
+        )
 
     async def wait_for_selector(
         self,
         selector: str,
-        timeout: int = None,
-        state: Literal["attached", "detached", "hidden", "visible"] = None,
-    ) -> typing.Union["ElementHandle", NoneType]:
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        state: typing.Optional[
+            Literal["attached", "detached", "hidden", "visible"]
+        ] = None,
+    ) -> typing.Optional["ElementHandle"]:
         """Frame.wait_for_selector
 
-        Returns when element specified by selector satisfies `state` option. Resolves to `null` if waiting for `hidden` or
+        Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
         `detached`.
-        Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at
-        the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the
-        selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
+
+        **NOTE** Playwright automatically waits for element to be ready before performing an action. Using `Locator`
+        objects and web-first assertions make the code wait-for-selector-free.
+
+        Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If
+        at the moment of calling the method `selector` already satisfies the condition, the method will return immediately.
+        If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
+
+        **Usage**
+
         This method works across navigations:
 
+        ```py
+        import asyncio
+        from playwright.async_api import async_playwright, Playwright
+
+        async def run(playwright: Playwright):
+            chromium = playwright.chromium
+            browser = await chromium.launch()
+            page = await browser.new_page()
+            for current_url in [\"https://google.com\", \"https://bbc.com\"]:
+                await page.goto(current_url, wait_until=\"domcontentloaded\")
+                element = await page.main_frame.wait_for_selector(\"img\")
+                print(\"Loaded image: \" + str(await element.get_attribute(\"src\")))
+            await browser.close()
+
+        async def main():
+            async with async_playwright() as playwright:
+                await run(playwright)
+        asyncio.run(main())
+        ```
+
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        state : Optional[Literal['attached', 'detached', 'hidden', 'visible']]
+            A selector to query for.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        state : Union["attached", "detached", "hidden", "visible", None]
             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.
+            - `'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.
 
         Returns
         -------
-        Optional[ElementHandle]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> frame.wait_for_selector started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.waitForSelector(
-                    selector=selector, timeout=timeout, state=state
-                )
-            )
-            log_api("<= frame.wait_for_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.wait_for_selector failed")
-            raise e
+        return mapping.from_impl_nullable(
+            await self._impl_obj.wait_for_selector(
+                selector=selector,
+                strict=strict,
+                timeout=to_milliseconds(timeout),
+                state=state,
+            )
+        )
 
-    async def dispatch_event(
+    async def is_checked(
         self,
         selector: str,
-        type: str,
-        event_init: typing.Dict = None,
-        timeout: int = None,
-    ) -> NoneType:
-        """Frame.dispatch_event
-
-        The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the elment, `click`
-        is dispatched. This is equivalend to calling
-        element.click().
-        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
-        and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
-        Since `eventInit` is event-specific, please refer to the events documentation for the lists of initial properties:
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Frame.is_checked
 
-        DragEvent
-        FocusEvent
-        KeyboardEvent
-        MouseEvent
-        PointerEvent
-        TouchEvent
-        Event
-
-        You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
+        Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        type : str
-            DOM event type: `"click"`, `"dragstart"`, etc.
-        event_init : Optional[Dict]
-            Optional event-specific initialization properties.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
         """
 
-        try:
-            log_api("=> frame.dispatch_event started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.dispatchEvent(
-                    selector=selector,
-                    type=type,
-                    eventInit=mapping.to_impl(event_init),
-                    timeout=timeout,
-                )
-            )
-            log_api("<= frame.dispatch_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.dispatch_event failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_checked(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def eval_on_selector(
+    async def is_disabled(
         self,
         selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-    ) -> typing.Any:
-        """Frame.eval_on_selector
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Frame.is_disabled
 
-        Returns the return value of `pageFunction`
-        The method finds an element matching the specified selector within the frame and passes it as a first argument to
-        `pageFunction`. See Working with selectors for more details. If no elements match the
-        selector, the method throws an error.
-        If `pageFunction` returns a Promise, then `frame.$eval` would wait for the promise to resolve and return its value.
-        Examples:
+        Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability#enabled).
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        Any
+        bool
         """
 
-        try:
-            log_api("=> frame.eval_on_selector started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.evalOnSelector(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= frame.eval_on_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.eval_on_selector failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_disabled(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def eval_on_selector_all(
+    async def is_editable(
         self,
         selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-    ) -> typing.Any:
-        """Frame.eval_on_selector_all
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Frame.is_editable
 
-        Returns the return value of `pageFunction`
-        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`. See Working with selectors for more details.
-        If `pageFunction` returns a Promise, then `frame.$$eval` would wait for the promise to resolve and return its value.
-        Examples:
+        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
-
-        Returns
-        -------
-        Any
-        """
-
-        try:
-            log_api("=> frame.eval_on_selector_all started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.evalOnSelectorAll(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= frame.eval_on_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.eval_on_selector_all failed")
-            raise e
-
-    async def content(self) -> str:
-        """Frame.content
-
-        Gets the full HTML contents of the frame, including the doctype.
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        str
+        bool
         """
 
-        try:
-            log_api("=> frame.content started")
-            result = mapping.from_maybe_impl(await self._impl_obj.content())
-            log_api("<= frame.content succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.content failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_editable(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def set_content(
+    async def is_enabled(
         self,
-        html: str,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-    ) -> NoneType:
-        """Frame.set_content
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Frame.is_enabled
+
+        Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
 
         Parameters
         ----------
-        html : str
-            HTML markup to assign to the page.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
-        """
-
-        try:
-            log_api("=> frame.set_content started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.setContent(
-                    html=html, timeout=timeout, waitUntil=wait_until
-                )
-            )
-            log_api("<= frame.set_content succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.set_content failed")
-            raise e
-
-    def is_detached(self) -> bool:
-        """Frame.is_detached
-
-        Returns `true` if the frame has been detached, or `false` otherwise.
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
         bool
         """
 
-        try:
-            log_api("=> frame.is_detached started")
-            result = mapping.from_maybe_impl(self._impl_obj.isDetached())
-            log_api("<= frame.is_detached succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.is_detached failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_enabled(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def add_script_tag(
-        self,
-        url: str = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content: str = None,
-        type: str = None,
-    ) -> "ElementHandle":
-        """Frame.add_script_tag
+    async def is_hidden(
+        self, selector: str, *, strict: typing.Optional[bool] = None
+    ) -> bool:
+        """Frame.is_hidden
 
-        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.
+        Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability#visible).  `selector` that
+        does not match any elements is considered hidden.
 
         Parameters
         ----------
-        url : Optional[str]
-            URL of a script to be added.
-        path : Union[str, pathlib.Path, NoneType]
-            Path to the JavaScript file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory.
-        content : Optional[str]
-            Raw JavaScript content to be injected into frame.
-        type : Optional[str]
-            Script type. Use 'module' in order to load a Javascript ES6 module. See script for more details.
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
 
         Returns
         -------
-        ElementHandle
+        bool
         """
 
-        try:
-            log_api("=> frame.add_script_tag started")
-            result = mapping.from_impl(
-                await self._impl_obj.addScriptTag(
-                    url=url, path=path, content=content, type=type
-                )
-            )
-            log_api("<= frame.add_script_tag succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.add_script_tag failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_hidden(selector=selector, strict=strict)
+        )
 
-    async def add_style_tag(
-        self,
-        url: str = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content: str = None,
-    ) -> "ElementHandle":
-        """Frame.add_style_tag
+    async def is_visible(
+        self, selector: str, *, strict: typing.Optional[bool] = None
+    ) -> bool:
+        """Frame.is_visible
 
-        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.
+        Returns whether the element is [visible](https://playwright.dev/python/docs/actionability#visible). `selector` that does not match any elements
+        is considered not visible.
 
         Parameters
         ----------
-        url : Optional[str]
-            URL of the `<link>` tag.
-        path : Union[str, pathlib.Path, NoneType]
-            Path to the CSS file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory.
-        content : Optional[str]
-            Raw CSS content to be injected into frame.
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
 
         Returns
         -------
-        ElementHandle
+        bool
         """
 
-        try:
-            log_api("=> frame.add_style_tag started")
-            result = mapping.from_impl(
-                await self._impl_obj.addStyleTag(url=url, path=path, content=content)
-            )
-            log_api("<= frame.add_style_tag succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.add_style_tag failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_visible(selector=selector, strict=strict)
+        )
 
-    async def click(
+    async def dispatch_event(
         self,
         selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        click_count: int = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.click
+        type: str,
+        event_init: typing.Optional[typing.Dict] = None,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Frame.dispatch_event
 
-        This method clicks an element matching `selector` by performing the following steps:
+        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).
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        **Usage**
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
-
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
-            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
-            Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> frame.click started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.click(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    clickCount=click_count,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= frame.click succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.click failed")
-            raise e
-
-    async def dblclick(
-        self,
-        selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.dblclick
+        ```py
+        await frame.dispatch_event(\"button#submit\", \"click\")
+        ```
 
-        This method double clicks an element matching `selector` by performing the following steps:
+        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit`
+        properties and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to double click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if the first click of the `dblclick()` triggers a navigation event, this method will reject.
+        Since `eventInit` 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)
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
 
-        **NOTE** `frame.dblclick()` dispatches two `click` events and a single `dblclick` event.
+        ```py
+        # note you can only create data_transfer in chromium and firefox
+        data_transfer = await frame.evaluate_handle(\"new DataTransfer()\")
+        await frame.dispatch_event(\"#source\", \"dragstart\", { \"dataTransfer\": data_transfer })
+        ```
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
-            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
-            Defaults to `left`.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> frame.dblclick started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.dblclick(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= frame.dblclick succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.dblclick failed")
-            raise e
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        type : str
+            DOM event type: `"click"`, `"dragstart"`, etc.
+        event_init : Union[Dict, None]
+            Optional event-specific initialization properties.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.dispatch_event(
+                selector=selector,
+                type=type,
+                eventInit=mapping.to_impl(event_init),
+                strict=strict,
+                timeout=to_milliseconds(timeout),
+            )
+        )
 
-    async def tap(
+    async def eval_on_selector(
         self,
         selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.tap
-
-        This method taps an element matching `selector` by performing the following steps:
-
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.touchscreen to tap the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        expression: str,
+        arg: typing.Optional[typing.Any] = None,
+        *,
+        strict: typing.Optional[bool] = None,
+    ) -> typing.Any:
+        """Frame.eval_on_selector
 
-        **NOTE** `frame.tap()` requires that the `hasTouch` option of the browser context be set to true.
+        Returns the return value of `expression`.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        The method finds an element matching the specified selector within the frame and passes it as a first argument to
+        `expression`. If no elements match the selector, the method throws an error.
 
-        try:
-            log_api("=> frame.tap started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.tap(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= frame.tap succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.tap failed")
-            raise e
+        If `expression` returns a [Promise], then `frame.eval_on_selector()` would wait for the promise to resolve
+        and return its value.
 
-    async def fill(
-        self, selector: str, value: str, timeout: int = None, no_wait_after: bool = None
-    ) -> NoneType:
-        """Frame.fill
+        **Usage**
 
-        This method waits for an element matching `selector`, waits for actionability checks, focuses the
-        element, fills it and triggers an `input` event after filling. If the element matching `selector` is not an `<input>`,
-        `<textarea>` or `[contenteditable]` element, this method throws an error. Note that you can pass an empty string to
-        clear the input field.
-        To send fine-grained keyboard events, use frame.type(selector, text[, options]).
+        ```py
+        search_value = await frame.eval_on_selector(\"#search\", \"el => el.value\")
+        preload_href = await frame.eval_on_selector(\"link[rel=preload]\", \"el => el.href\")
+        html = await frame.eval_on_selector(\".main-container\", \"(e, suffix) => e.outerHTML + suffix\", \"hello\")
+        ```
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        value : str
-            Value to fill for the `<input>`, `<textarea>` or `[contenteditable]` element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
+            A selector to query for.
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        strict : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Any
         """
 
-        try:
-            log_api("=> frame.fill started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.fill(
-                    selector=selector,
-                    value=value,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= frame.fill succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.fill failed")
-            raise e
-
-    async def focus(self, selector: str, timeout: int = None) -> NoneType:
-        """Frame.focus
+        return mapping.from_maybe_impl(
+            await self._impl_obj.eval_on_selector(
+                selector=selector,
+                expression=expression,
+                arg=mapping.to_impl(arg),
+                strict=strict,
+            )
+        )
 
-        This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the method
-        waits until a matching element appears in the DOM.
+    async def eval_on_selector_all(
+        self, selector: str, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> typing.Any:
+        """Frame.eval_on_selector_all
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        """
+        Returns the return value of `expression`.
 
-        try:
-            log_api("=> frame.focus started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.focus(selector=selector, timeout=timeout)
-            )
-            log_api("<= frame.focus succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.focus failed")
-            raise e
+        The method finds all elements matching the specified selector within the frame and passes an array of matched
+        elements as a first argument to `expression`.
 
-    async def text_content(
-        self, selector: str, timeout: int = None
-    ) -> typing.Union[str, NoneType]:
-        """Frame.text_content
+        If `expression` returns a [Promise], then `frame.eval_on_selector_all()` would wait for the promise to resolve
+        and return its value.
 
-        Resolves to the `element.textContent`.
+        **Usage**
+
+        ```py
+        divs_counts = await frame.eval_on_selector_all(\"div\", \"(divs, min) => divs.length >= min\", 10)
+        ```
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+            A selector to query for.
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
-        Optional[str]
+        Any
         """
 
-        try:
-            log_api("=> frame.text_content started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.textContent(selector=selector, timeout=timeout)
+        return mapping.from_maybe_impl(
+            await self._impl_obj.eval_on_selector_all(
+                selector=selector, expression=expression, arg=mapping.to_impl(arg)
             )
-            log_api("<= frame.text_content succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.text_content failed")
-            raise e
-
-    async def inner_text(self, selector: str, timeout: int = None) -> str:
-        """Frame.inner_text
+        )
 
-        Resolves to the `element.innerText`.
+    async def content(self) -> str:
+        """Frame.content
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        Gets the full HTML contents of the frame, including the doctype.
 
         Returns
         -------
         str
         """
 
-        try:
-            log_api("=> frame.inner_text started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.innerText(selector=selector, timeout=timeout)
-            )
-            log_api("<= frame.inner_text succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.inner_text failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.content())
 
-    async def inner_html(self, selector: str, timeout: int = None) -> str:
-        """Frame.inner_html
+    async def set_content(
+        self,
+        html: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> None:
+        """Frame.set_content
 
-        Resolves to the `element.innerHTML`.
+        This method internally calls [document.write()](https://developer.mozilla.org/en-US/docs/Web/API/Document/write),
+        inheriting all its specific characteristics and behaviors.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-
-        Returns
-        -------
-        str
+        html : str
+            HTML markup to assign to the page.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
         """
 
-        try:
-            log_api("=> frame.inner_html started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.innerHTML(selector=selector, timeout=timeout)
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_content(
+                html=html, timeout=to_milliseconds(timeout), waitUntil=wait_until
             )
-            log_api("<= frame.inner_html succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.inner_html failed")
-            raise e
-
-    async def get_attribute(
-        self, selector: str, name: str, timeout: int = None
-    ) -> typing.Union[str, NoneType]:
-        """Frame.get_attribute
+        )
 
-        Returns element attribute value.
+    def is_detached(self) -> bool:
+        """Frame.is_detached
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        name : str
-            Attribute name to get the value for.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        Returns `true` if the frame has been detached, or `false` otherwise.
 
         Returns
         -------
-        Optional[str]
+        bool
         """
 
-        try:
-            log_api("=> frame.get_attribute started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.getAttribute(
-                    selector=selector, name=name, timeout=timeout
-                )
-            )
-            log_api("<= frame.get_attribute succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.get_attribute failed")
-            raise e
+        return mapping.from_maybe_impl(self._impl_obj.is_detached())
 
-    async def hover(
+    async def add_script_tag(
         self,
-        selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-    ) -> NoneType:
-        """Frame.hover
-
-        This method hovers over an element matching `selector` by performing the following steps:
+        *,
+        url: typing.Optional[str] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
+        type: typing.Optional[str] = None,
+    ) -> "ElementHandle":
+        """Frame.add_script_tag
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to hover over the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        Returns the added tag when the script's onload fires or when the script content was injected into frame.
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        Adds a `<script>` tag into the page with the desired url or content.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
+        url : Union[str, None]
+            URL of a script to be added.
+        path : Union[pathlib.Path, str, None]
+            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.
+        content : Union[str, None]
+            Raw JavaScript content to be injected into frame.
+        type : Union[str, None]
+            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.
+
+        Returns
+        -------
+        ElementHandle
         """
 
-        try:
-            log_api("=> frame.hover started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.hover(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    timeout=timeout,
-                    force=force,
-                )
-            )
-            log_api("<= frame.hover succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.hover failed")
-            raise e
+        return mapping.from_impl(
+            await self._impl_obj.add_script_tag(
+                url=url, path=path, content=content, type=type
+            )
+        )
 
-    async def select_option(
+    async def add_style_tag(
         self,
-        selector: str,
-        value: typing.Union[str, typing.List[str]] = None,
-        index: typing.Union[int, typing.List[int]] = None,
-        label: typing.Union[str, typing.List[str]] = None,
-        element: typing.Union["ElementHandle", typing.List["ElementHandle"]] = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> typing.List[str]:
-        """Frame.select_option
+        *,
+        url: typing.Optional[str] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
+    ) -> "ElementHandle":
+        """Frame.add_style_tag
 
-        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. If there's no `<select>` element
-        matching `selector`, the method throws an error.
+        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.
 
         Parameters
         ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
+        url : Union[str, None]
+            URL of the `<link>` tag.
+        path : Union[pathlib.Path, str, None]
+            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.
+        content : Union[str, None]
+            Raw CSS content to be injected into frame.
 
         Returns
         -------
-        List[str]
+        ElementHandle
         """
 
-        try:
-            log_api("=> frame.select_option started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.selectOption(
-                    selector=selector,
-                    value=value,
-                    index=index,
-                    label=label,
-                    element=mapping.to_impl(element),
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= frame.select_option succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.select_option failed")
-            raise e
+        return mapping.from_impl(
+            await self._impl_obj.add_style_tag(url=url, path=path, content=content)
+        )
 
-    async def set_input_files(
+    async def click(
         self,
         selector: str,
-        files: typing.Union[
-            str,
-            pathlib.Path,
-            "FilePayload",
-            typing.List[str],
-            typing.List[pathlib.Path],
-            typing.List["FilePayload"],
-        ],
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.set_input_files
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.click
 
-        This method expects `selector` to point to an input
-        element.
-        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 clicks an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to click in the center of the element, or the specified `position`.
+        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        files : Union[str, pathlib.Path, Dict, List[str], List[pathlib.Path], List[Dict]]
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> frame.set_input_files started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.setInputFiles(
-                    selector=selector,
-                    files=files,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= frame.set_input_files succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.set_input_files failed")
-            raise e
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
+            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
+        button : Union["left", "middle", "right", None]
+            Defaults to `left`.
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            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.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.click(
+                selector=selector,
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                delay=delay,
+                button=button,
+                clickCount=click_count,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                trial=trial,
+            )
+        )
 
-    async def type(
+    async def dblclick(
         self,
         selector: str,
-        text: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.type
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.dblclick
+
+        This method double clicks an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to double click in the center of the element, or the specified `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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
-        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]).
-        To press a special key, like `Control` or `ArrowDown`, use keyboard.press(key[, options]).
+        **NOTE** `frame.dblclick()` dispatches two `click` events and a single `dblclick` event.
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        text : str
-            A text to type into a focused element.
-        delay : Optional[int]
-            Time to wait between key presses in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> frame.type started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.type(
-                    selector=selector,
-                    text=text,
-                    delay=delay,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= frame.type succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.type failed")
-            raise e
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
+            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
+        button : Union["left", "middle", "right", None]
+            Defaults to `left`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.dblclick(
+                selector=selector,
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                delay=delay,
+                button=button,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                trial=trial,
+            )
+        )
 
-    async def press(
+    async def tap(
         self,
         selector: str,
-        key: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.press
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.tap
 
-        `key` can specify the intended keyboardEvent.key
-        value or a single character to generate the text for. A superset of the `key` values can be found
-        here. 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 suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
-        Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
-        If `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"` or `key: "Control+Shift+T"` are supported as well. When speficied with the
-        modifier, modifier is pressed and being held while the subsequent key is being pressed.
+        This method taps an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to tap the center of the element, or the specified `position`.
+
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **NOTE** `frame.tap()` requires that the `hasTouch` option of the browser context be set to true.
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        key : str
-            Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
-        delay : Optional[int]
-            Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> frame.press started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.press(
-                    selector=selector,
-                    key=key,
-                    delay=delay,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= frame.press succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.press failed")
-            raise e
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.tap(
+                selector=selector,
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                trial=trial,
+            )
+        )
 
-    async def check(
+    async def fill(
         self,
         selector: str,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.check
+        value: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.fill
 
-        This method checks an element matching `selector` by performing the following steps:
+        This method waits for an element matching `selector`, waits for [actionability](https://playwright.dev/python/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.
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already checked, this method returns immediately.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now checked. If not, this method rejects.
+        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.
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        To send fine-grained keyboard events, use `locator.press_sequentially()`.
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> frame.check started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.check(
-                    selector=selector,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= frame.check succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.check failed")
-            raise e
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        value : str
+            Value to fill for the `<input>`, `<textarea>` or `[contenteditable]` element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.fill(
+                selector=selector,
+                value=value,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                force=force,
+            )
+        )
 
-    async def uncheck(
+    def locator(
         self,
         selector: str,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.uncheck
+        *,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has: typing.Optional["Locator"] = None,
+        has_not: typing.Optional["Locator"] = None,
+    ) -> "Locator":
+        """Frame.locator
 
-        This method checks an element matching `selector` by performing the following steps:
+        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.
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already unchecked, this method returns immediately.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now unchecked. If not, this method rejects.
+        [Learn more about locators](https://playwright.dev/python/docs/locators).
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        [Learn more about locators](https://playwright.dev/python/docs/locators).
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> frame.uncheck started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.uncheck(
-                    selector=selector,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= frame.uncheck succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.uncheck failed")
-            raise e
-
-    async def wait_for_timeout(self, timeout: int) -> NoneType:
-        """Frame.wait_for_timeout
+            A selector to use when resolving DOM element.
+        has_text : Union[Pattern[str], str, None]
+            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>`.
+        has_not_text : Union[Pattern[str], str, None]
+            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.
+        has : Union[Locator, None]
+            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`s.
+        has_not : Union[Locator, None]
+            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`s.
 
-        Returns a promise that resolves after the timeout.
-        Note that `frame.wait_for_timeout()` 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.
-
-        Parameters
-        ----------
-        timeout : int
-            A timeout to wait for
+        Returns
+        -------
+        Locator
         """
 
-        try:
-            log_api("=> frame.wait_for_timeout started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.waitForTimeout(timeout=timeout)
+        return mapping.from_impl(
+            self._impl_obj.locator(
+                selector=selector,
+                hasText=has_text,
+                hasNotText=has_not_text,
+                has=has._impl_obj if has else None,
+                hasNot=has_not._impl_obj if has_not else None,
             )
-            log_api("<= frame.wait_for_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.wait_for_timeout failed")
-            raise e
+        )
 
-    async def wait_for_function(
+    def get_by_alt_text(
         self,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-        timeout: int = None,
-        polling: typing.Union[int, Literal["raf"]] = None,
-    ) -> "JSHandle":
-        """Frame.wait_for_function
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Frame.get_by_alt_text
 
-        Returns when the `pageFunction` returns a truthy value. It resolves to a JSHandle of the truthy value.
-        The `waitForFunction` can be used to observe viewport size change:
+        Allows locating elements by their alt text.
 
-        To pass an argument from Node.js to the predicate of `frame.wait_for_function` function:
+        **Usage**
+
+        For example, this method will find the image by alt text \"Playwright logo\":
+
+        ```html
+        <img alt='Playwright logo'>
+        ```
+
+        ```py
+        await page.get_by_alt_text(\"Playwright logo\").click()
+        ```
 
         Parameters
         ----------
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
-        timeout : Optional[int]
-            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).
-        polling : Union[int, 'raf', NoneType]
-            If `polling` is `'raf'`, then `pageFunction` is constantly executed in `requestAnimationFrame` callback. If `polling` is a number, then it is treated as an interval in milliseconds at which the function would be executed. Defaults to `raf`.
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
 
         Returns
         -------
-        JSHandle
+        Locator
         """
 
-        try:
-            log_api("=> frame.wait_for_function started")
-            result = mapping.from_impl(
-                await self._impl_obj.waitForFunction(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                    timeout=timeout,
-                    polling=polling,
-                )
-            )
-            log_api("<= frame.wait_for_function succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.wait_for_function failed")
-            raise e
+        return mapping.from_impl(self._impl_obj.get_by_alt_text(text=text, exact=exact))
 
-    async def title(self) -> str:
-        """Frame.title
+    def get_by_label(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Frame.get_by_label
 
-        Returns the page title.
+        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\">
+        ```
+
+        ```py
+        await page.get_by_label(\"Username\").fill(\"john\")
+        await page.get_by_label(\"Password\").fill(\"secret\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
 
         Returns
         -------
-        str
+        Locator
         """
 
-        try:
-            log_api("=> frame.title started")
-            result = mapping.from_maybe_impl(await self._impl_obj.title())
-            log_api("<= frame.title succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.title failed")
-            raise e
+        return mapping.from_impl(self._impl_obj.get_by_label(text=text, exact=exact))
 
-    def expect_load_state(
+    def get_by_placeholder(
         self,
-        state: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager[typing.Union["Response", NoneType]]:
-        """Frame.expect_load_state
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Frame.get_by_placeholder
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        Allows locating input elements by the placeholder text.
 
-        async with page.expect_loadstate() as event_info:
-            await page.click("button")
-        value = event_info.value
+        **Usage**
 
-        Parameters
-        ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        return AsyncEventContextManager(self._impl_obj.waitForLoadState(state, timeout))
+        For example, consider the following DOM structure.
 
-    def expect_navigation(
-        self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager[typing.Union["Response", NoneType]]:
-        """Frame.expect_navigation
+        ```html
+        <input type=\"email\" placeholder=\"name@example.com\" />
+        ```
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        You can fill the input after locating it by the placeholder text:
 
-        async with page.expect_navigation() as event_info:
-            await page.click("button")
-        value = event_info.value
+        ```py
+        await page.get_by_placeholder(\"name@example.com\").fill(\"playwright@microsoft.com\")
+        ```
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
         """
-        return AsyncEventContextManager(
-            self._impl_obj.waitForNavigation(url, wait_until, timeout)
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_placeholder(text=text, exact=exact)
         )
 
+    def get_by_role(
+        self,
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
+        ],
+        *,
+        checked: typing.Optional[bool] = None,
+        disabled: typing.Optional[bool] = None,
+        expanded: typing.Optional[bool] = None,
+        include_hidden: typing.Optional[bool] = None,
+        level: typing.Optional[int] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        pressed: typing.Optional[bool] = None,
+        selected: typing.Optional[bool] = None,
+        exact: typing.Optional[bool] = None,
+        description: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> "Locator":
+        """Frame.get_by_role
+
+        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.
 
-mapping.register(FrameImpl, Frame)
+        ```html
+        <h3>Sign up</h3>
+        <label>
+          <input type=\"checkbox\" /> Subscribe
+        </label>
+        <br/>
+        <button>Submit</button>
+        ```
 
+        You can locate each element by its implicit role:
 
-class Worker(AsyncBase):
-    def __init__(self, obj: WorkerImpl):
-        super().__init__(obj)
+        ```py
+        await expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
 
-    @property
-    def url(self) -> str:
-        """Worker.url
+        await page.get_by_role(\"checkbox\", name=\"Subscribe\").check()
 
-        Returns
-        -------
-        str
-        """
-        return mapping.from_maybe_impl(self._impl_obj.url)
+        await page.get_by_role(\"button\", name=re.compile(\"submit\", re.IGNORECASE)).click()
+        ```
 
-    async def evaluate(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
-    ) -> typing.Any:
-        """Worker.evaluate
+        **Details**
+
+        Role selector **does not replace** accessibility audits and conformance tests, but rather gives early feedback
+        about the ARIA guidelines.
 
-        Returns the return value of `pageFunction`
-        If the function passed to the `worker.evaluate` returns a Promise, then `worker.evaluate` would wait for the promise
-        to resolve and return its value.
-        If the function passed to the `worker.evaluate` returns a non-Serializable value, then `worker.evaluate` resolves to
-        `undefined`. DevTools Protocol also supports transferring some additional values that are not serializable by `JSON`:
-        `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
+        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.
 
         Parameters
         ----------
-        expression : str
-            Function to be evaluated in the worker context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        checked : Union[bool, None]
+            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).
+        disabled : Union[bool, None]
+            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).
+
+        expanded : Union[bool, None]
+            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).
+        include_hidden : Union[bool, None]
+            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).
+        level : Union[int, None]
+            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).
+        name : Union[Pattern[str], str, None]
+            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` to control this behavior.
+
+            Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
+        pressed : Union[bool, None]
+            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).
+        selected : Union[bool, None]
+            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).
+        exact : Union[bool, None]
+            Whether `name` and `description` are matched exactly: case-sensitive and whole-string. Defaults to false. Ignored
+            when the value is a regular expression. Note that exact match still trims whitespace.
+        description : Union[Pattern[str], str, None]
+            Option to match the [accessible description](https://w3c.github.io/accname/#dfn-accessible-description). By
+            default, matching is case-insensitive and searches for a substring, use `exact` to control this behavior.
+
+            Learn more about [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
 
         Returns
         -------
-        Any
-        """
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_role(
+                role=role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=include_hidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
 
-        try:
-            log_api("=> worker.evaluate started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.evaluate(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= worker.evaluate succeded")
-            return result
-        except Exception as e:
-            log_api("<= worker.evaluate failed")
-            raise e
+    def get_by_test_id(
+        self, test_id: typing.Union[str, typing.Pattern[str]]
+    ) -> "Locator":
+        """Frame.get_by_test_id
 
-    async def evaluate_handle(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
-    ) -> "JSHandle":
-        """Worker.evaluate_handle
+        Locate element by the test id.
+
+        **Usage**
+
+        Consider the following DOM structure.
+
+        ```html
+        <button data-testid=\"directions\">Itinéraire</button>
+        ```
 
-        Returns the return value of `pageFunction` as in-page object (JSHandle).
-        The only difference between `worker.evaluate` and `worker.evaluate_handle` is that `worker.evaluate_handle` returns
-        in-page object (JSHandle).
-        If the function passed to the `worker.evaluate_handle` returns a Promise, then `worker.evaluate_handle` would wait for
-        the promise to resolve and return its value.
+        You can locate the element by its test id:
+
+        ```py
+        await page.get_by_test_id(\"directions\").click()
+        ```
+
+        **Details**
+
+        By default, the `data-testid` attribute is used as a test id. Use `selectors.set_test_id_attribute()` to
+        configure a different test id attribute if necessary.
 
         Parameters
         ----------
-        expression : str
-            Function to be evaluated in the page context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+        test_id : Union[Pattern[str], str]
+            Id to locate the element by.
 
         Returns
         -------
-        JSHandle
+        Locator
         """
 
-        try:
-            log_api("=> worker.evaluate_handle started")
-            result = mapping.from_impl(
-                await self._impl_obj.evaluateHandle(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= worker.evaluate_handle succeded")
-            return result
-        except Exception as e:
-            log_api("<= worker.evaluate_handle failed")
-            raise e
+        return mapping.from_impl(self._impl_obj.get_by_test_id(testId=test_id))
 
+    def get_by_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Frame.get_by_text
 
-mapping.register(WorkerImpl, Worker)
+        Allows locating elements that contain given text.
 
+        See also `locator.filter()` that allows to match by another criteria, like an accessible role, and then
+        filter by the text content.
 
-class Selectors(AsyncBase):
-    def __init__(self, obj: SelectorsImpl):
-        super().__init__(obj)
+        **Usage**
 
-    async def register(
-        self,
-        name: str,
-        source: str = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content_script: bool = None,
-    ) -> NoneType:
-        """Selectors.register
+        Consider the following DOM structure:
 
-        An example of registering selector engine that queries elements based on a tag name:
+        ```html
+        <div>Hello <span>world</span></div>
+        <div>Hello</div>
+        ```
 
-        Parameters
-        ----------
-        name : str
-            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.
-        source : Optional[str]
-            Script that evaluates to a selector engine instance.
-        content_script : Optional[bool]
-            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.
-        """
+        You can locate by text substring, exact string, or a regular expression:
 
-        try:
-            log_api("=> selectors.register started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.register(
-                    name=name, source=source, path=path, contentScript=content_script
-                )
-            )
-            log_api("<= selectors.register succeded")
-            return result
-        except Exception as e:
-            log_api("<= selectors.register failed")
-            raise e
+        ```py
+        # Matches <span>
+        page.get_by_text(\"world\")
 
+        # Matches first <div>
+        page.get_by_text(\"Hello world\")
 
-mapping.register(SelectorsImpl, Selectors)
+        # Matches second <div>
+        page.get_by_text(\"Hello\", exact=True)
 
+        # Matches both <div>s
+        page.get_by_text(re.compile(\"Hello\"))
 
-class ConsoleMessage(AsyncBase):
-    def __init__(self, obj: ConsoleMessageImpl):
-        super().__init__(obj)
+        # Matches second <div>
+        page.get_by_text(re.compile(\"^hello$\", re.IGNORECASE))
+        ```
 
-    @property
-    def type(self) -> str:
-        """ConsoleMessage.type
+        **Details**
 
-        One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`,
-        `'trace'`, `'clear'`, `'startGroup'`, `'startGroupCollapsed'`, `'endGroup'`, `'assert'`, `'profile'`, `'profileEnd'`,
-        `'count'`, `'timeEnd'`.
+        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.
 
-        Returns
-        -------
-        str
-        """
-        return mapping.from_maybe_impl(self._impl_obj.type)
+        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\">`.
 
-    @property
-    def text(self) -> str:
-        """ConsoleMessage.text
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
 
         Returns
         -------
-        str
+        Locator
         """
-        return mapping.from_maybe_impl(self._impl_obj.text)
-
-    @property
-    def args(self) -> typing.List["JSHandle"]:
-        """ConsoleMessage.args
 
-        Returns
-        -------
-        List[JSHandle]
-        """
-        return mapping.from_impl_list(self._impl_obj.args)
+        return mapping.from_impl(self._impl_obj.get_by_text(text=text, exact=exact))
 
-    @property
-    def location(self) -> "SourceLocation":
-        """ConsoleMessage.location
+    def get_by_title(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Frame.get_by_title
 
-        Returns
-        -------
-        {"url": str, "lineNumber": int, "columnNumber": int}
-        """
-        return mapping.from_impl(self._impl_obj.location)
+        Allows locating elements by their title attribute.
 
+        **Usage**
 
-mapping.register(ConsoleMessageImpl, ConsoleMessage)
+        Consider the following DOM structure.
 
+        ```html
+        <span title='Issues count'>25 issues</span>
+        ```
 
-class Dialog(AsyncBase):
-    def __init__(self, obj: DialogImpl):
-        super().__init__(obj)
+        You can check the issues count after locating it by the title text:
 
-    @property
-    def type(self) -> str:
-        """Dialog.type
+        ```py
+        await expect(page.get_by_title(\"Issues count\")).to_have_text(\"25 issues\")
+        ```
 
-        Returns dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`.
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
 
         Returns
         -------
-        str
+        Locator
         """
-        return mapping.from_maybe_impl(self._impl_obj.type)
 
-    @property
-    def message(self) -> str:
-        """Dialog.message
+        return mapping.from_impl(self._impl_obj.get_by_title(text=text, exact=exact))
 
-        A message displayed in the dialog.
+    def frame_locator(self, selector: str) -> "FrameLocator":
+        """Frame.frame_locator
 
-        Returns
-        -------
-        str
-        """
-        return mapping.from_maybe_impl(self._impl_obj.message)
+        When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements
+        in that iframe.
 
-    @property
-    def default_value(self) -> str:
-        """Dialog.default_value
+        **Usage**
 
-        If dialog is prompt, returns default prompt value. Otherwise, returns empty string.
+        Following snippet locates element with text \"Submit\" in the iframe with id `my-frame`, like `<iframe
+        id=\"my-frame\">`:
+
+        ```py
+        locator = frame.frame_locator(\"#my-iframe\").get_by_text(\"Submit\")
+        await locator.click()
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to use when resolving DOM element.
 
         Returns
         -------
-        str
+        FrameLocator
         """
-        return mapping.from_maybe_impl(self._impl_obj.defaultValue)
 
-    async def accept(self, prompt_text: str = None) -> NoneType:
-        """Dialog.accept
+        return mapping.from_impl(self._impl_obj.frame_locator(selector=selector))
 
-        Returns when the dialog has been accepted.
+    async def focus(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Frame.focus
+
+        This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the
+        method waits until a matching element appears in the DOM.
 
         Parameters
         ----------
-        prompt_text : Optional[str]
-            A text to enter in prompt. Does not cause any effects if the dialog's `type` is not prompt. Optional.
-        """
-
-        try:
-            log_api("=> dialog.accept started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.accept(promptText=prompt_text)
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.focus(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
             )
-            log_api("<= dialog.accept succeded")
-            return result
-        except Exception as e:
-            log_api("<= dialog.accept failed")
-            raise e
-
-    async def dismiss(self) -> NoneType:
-        """Dialog.dismiss
+        )
 
-        Returns when the dialog has been dismissed.
-        """
+    async def text_content(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Frame.text_content
 
-        try:
-            log_api("=> dialog.dismiss started")
-            result = mapping.from_maybe_impl(await self._impl_obj.dismiss())
-            log_api("<= dialog.dismiss succeded")
-            return result
-        except Exception as e:
-            log_api("<= dialog.dismiss failed")
-            raise e
+        Returns `element.textContent`.
 
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
-mapping.register(DialogImpl, Dialog)
+        Returns
+        -------
+        Union[str, None]
+        """
 
+        return mapping.from_maybe_impl(
+            await self._impl_obj.text_content(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
 
-class Download(AsyncBase):
-    def __init__(self, obj: DownloadImpl):
-        super().__init__(obj)
+    async def inner_text(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Frame.inner_text
 
-    @property
-    def url(self) -> str:
-        """Download.url
+        Returns `element.innerText`.
 
-        Returns downloaded url.
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.url)
 
-    @property
-    def suggested_filename(self) -> str:
-        """Download.suggested_filename
+        return mapping.from_maybe_impl(
+            await self._impl_obj.inner_text(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
 
-        Returns suggested filename for this download. It is typically computed by the browser from the
-        `Content-Disposition` response header
-        or the `download` attribute. See the spec on whatwg. Different
-        browsers can use different logic for computing it.
+    async def inner_html(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Frame.inner_html
+
+        Returns `element.innerHTML`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.suggestedFilename)
 
-    async def delete(self) -> NoneType:
-        """Download.delete
+        return mapping.from_maybe_impl(
+            await self._impl_obj.inner_html(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
 
-        Deletes the downloaded file.
-        """
+    async def get_attribute(
+        self,
+        selector: str,
+        name: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Frame.get_attribute
 
-        try:
-            log_api("=> download.delete started")
-            result = mapping.from_maybe_impl(await self._impl_obj.delete())
-            log_api("<= download.delete succeded")
-            return result
-        except Exception as e:
-            log_api("<= download.delete failed")
-            raise e
-
-    async def failure(self) -> typing.Union[str, NoneType]:
-        """Download.failure
+        Returns element attribute value.
 
-        Returns download error if any.
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        name : str
+            Attribute name to get the value for.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        Optional[str]
+        Union[str, None]
         """
 
-        try:
-            log_api("=> download.failure started")
-            result = mapping.from_maybe_impl(await self._impl_obj.failure())
-            log_api("<= download.failure succeded")
-            return result
-        except Exception as e:
-            log_api("<= download.failure failed")
-            raise e
-
-    async def path(self) -> typing.Union[str, NoneType]:
-        """Download.path
-
-        Returns path to the downloaded file in case of successful download.
+        return mapping.from_maybe_impl(
+            await self._impl_obj.get_attribute(
+                selector=selector,
+                name=name,
+                strict=strict,
+                timeout=to_milliseconds(timeout),
+            )
+        )
 
-        Returns
-        -------
-        Optional[str]
-        """
+    async def hover(
+        self,
+        selector: str,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.hover
 
-        try:
-            log_api("=> download.path started")
-            result = mapping.from_maybe_impl(await self._impl_obj.path())
-            log_api("<= download.path succeded")
-            return result
-        except Exception as e:
-            log_api("<= download.path failed")
-            raise e
-
-    async def save_as(self, path: typing.Union[str, pathlib.Path]) -> NoneType:
-        """Download.save_as
+        This method hovers over an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to hover over the center of the element, or the specified `position`.
 
-        Saves the download to a user-specified path.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
         Parameters
         ----------
-        path : Union[str, pathlib.Path]
-            Path where the download should be saved.
-        """
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.hover(
+                selector=selector,
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                force=force,
+                strict=strict,
+                trial=trial,
+            )
+        )
 
-        try:
-            log_api("=> download.save_as started")
-            result = mapping.from_maybe_impl(await self._impl_obj.saveAs(path=path))
-            log_api("<= download.save_as succeded")
-            return result
-        except Exception as e:
-            log_api("<= download.save_as failed")
-            raise e
+    async def drag_and_drop(
+        self,
+        source: str,
+        target: str,
+        *,
+        source_position: typing.Optional[Position] = None,
+        target_position: typing.Optional[Position] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
+        """Frame.drag_and_drop
 
+        Parameters
+        ----------
+        source : str
+            A selector to search for an element to drag. If there are multiple elements satisfying the selector, the first will
+            be used.
+        target : str
+            A selector to search for an element to drop onto. If there are multiple elements satisfying the selector, the first
+            will be used.
+        source_position : Union[{x: float, y: float}, None]
+            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.
+        target_position : Union[{x: float, y: float}, None]
+            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.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.drag_and_drop(
+                source=source,
+                target=target,
+                sourcePosition=source_position,
+                targetPosition=target_position,
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                timeout=to_milliseconds(timeout),
+                trial=trial,
+                steps=steps,
+            )
+        )
 
-mapping.register(DownloadImpl, Download)
+    async def select_option(
+        self,
+        selector: str,
+        value: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        *,
+        index: typing.Optional[typing.Union[int, typing.Sequence[int]]] = None,
+        label: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        element: typing.Optional[
+            typing.Union["ElementHandle", typing.Sequence["ElementHandle"]]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> typing.List[str]:
+        """Frame.select_option
 
+        This method waits for an element matching `selector`, waits for [actionability](https://playwright.dev/python/docs/actionability) checks, waits
+        until all specified options are present in the `<select>` element and selects these options.
 
-class Video(AsyncBase):
-    def __init__(self, obj: VideoImpl):
-        super().__init__(obj)
+        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.
 
-    async def path(self) -> str:
-        """Video.path
+        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**
+
+        ```py
+        # Single selection matching the value or label
+        await frame.select_option(\"select#colors\", \"blue\")
+        # single selection matching the label
+        await frame.select_option(\"select#colors\", label=\"blue\")
+        # multiple selection
+        await frame.select_option(\"select#colors\", value=[\"red\", \"green\", \"blue\"])
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        value : Union[Sequence[str], str, None]
+            Options to select by value. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        index : Union[Sequence[int], int, None]
+            Options to select by index. Optional.
+        label : Union[Sequence[str], str, None]
+            Options to select by label. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        element : Union[ElementHandle, Sequence[ElementHandle], None]
+            Option elements to select. Optional.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+
+        Returns
+        -------
+        List[str]
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.select_option(
+                selector=selector,
+                value=mapping.to_impl(value),
+                index=mapping.to_impl(index),
+                label=mapping.to_impl(label),
+                element=mapping.to_impl(element),
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                force=force,
+            )
+        )
+
+    async def input_value(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Frame.input_value
+
+        Returns `input.value` for the selected `<input>` or `<textarea>` or `<select>` element.
 
-        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.
+        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.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
         str
         """
 
-        try:
-            log_api("=> video.path started")
-            result = mapping.from_maybe_impl(await self._impl_obj.path())
-            log_api("<= video.path succeded")
-            return result
-        except Exception as e:
-            log_api("<= video.path failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.input_value(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def set_input_files(
+        self,
+        selector: str,
+        files: typing.Union[
+            str,
+            pathlib.Path,
+            FilePayload,
+            typing.Sequence[typing.Union[str, pathlib.Path]],
+            typing.Sequence[FilePayload],
+        ],
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.set_input_files
 
+        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.
 
-mapping.register(VideoImpl, Video)
+        This method expects `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.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        files : Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}]
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_input_files(
+                selector=selector,
+                files=mapping.to_impl(files),
+                strict=strict,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+            )
+        )
+
+    async def type(
+        self,
+        selector: str,
+        text: str,
+        *,
+        delay: typing.Optional[float] = None,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.type
 
+        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()`.
 
-class BindingCall(AsyncBase):
-    def __init__(self, obj: BindingCallImpl):
-        super().__init__(obj)
+        To press a special key, like `Control` or `ArrowDown`, use `keyboard.press()`.
 
-    async def call(self, func: typing.Callable) -> NoneType:
+        **Usage**
 
-        try:
-            log_api("=> binding_call.call started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.call(func=self._wrap_handler(func))
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        text : str
+            A text to type into a focused element.
+        delay : Union[float, None]
+            Time to wait between key presses in milliseconds. Defaults to 0.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.type(
+                selector=selector,
+                text=text,
+                delay=delay,
+                strict=strict,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
             )
-            log_api("<= binding_call.call succeded")
-            return result
-        except Exception as e:
-            log_api("<= binding_call.call failed")
-            raise e
+        )
 
+    async def press(
+        self,
+        selector: str,
+        key: str,
+        *,
+        delay: typing.Optional[float] = None,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.press
 
-mapping.register(BindingCallImpl, BindingCall)
+        `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` 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.
 
-class Page(AsyncBase):
-    def __init__(self, obj: PageImpl):
-        super().__init__(obj)
+        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.
 
-    @property
-    def accessibility(self) -> "Accessibility":
-        """Page.accessibility
+        Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
 
-        Returns
-        -------
-        Accessibility
-        """
-        return mapping.from_impl(self._impl_obj.accessibility)
+        If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective
+        texts.
 
-    @property
-    def keyboard(self) -> "Keyboard":
-        """Page.keyboard
+        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.
 
-        Returns
-        -------
-        Keyboard
-        """
-        return mapping.from_impl(self._impl_obj.keyboard)
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        key : str
+            Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
+        delay : Union[float, None]
+            Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.press(
+                selector=selector,
+                key=key,
+                delay=delay,
+                strict=strict,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+            )
+        )
 
-    @property
-    def mouse(self) -> "Mouse":
-        """Page.mouse
+    async def check(
+        self,
+        selector: str,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.check
 
-        Returns
-        -------
-        Mouse
-        """
-        return mapping.from_impl(self._impl_obj.mouse)
+        This method checks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
-    @property
-    def touchscreen(self) -> "Touchscreen":
-        """Page.touchscreen
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.check(
+                selector=selector,
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                trial=trial,
+            )
+        )
 
-        Returns
-        -------
-        Touchscreen
-        """
-        return mapping.from_impl(self._impl_obj.touchscreen)
+    async def uncheck(
+        self,
+        selector: str,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.uncheck
 
-    @property
-    def context(self) -> "BrowserContext":
-        """Page.context
+        This method checks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
-        Get the browser context that the page belongs to.
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.uncheck(
+                selector=selector,
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                trial=trial,
+            )
+        )
 
-        Returns
-        -------
-        BrowserContext
-        """
-        return mapping.from_impl(self._impl_obj.context)
+    async def wait_for_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """Frame.wait_for_timeout
 
-    @property
-    def main_frame(self) -> "Frame":
-        """Page.main_frame
+        Waits for the given `timeout` in milliseconds.
 
-        The page's main frame. Page is guaranteed to have a main frame which persists during navigations.
+        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.
 
-        Returns
-        -------
-        Frame
+        Parameters
+        ----------
+        timeout : float
+            A timeout to wait for
         """
-        return mapping.from_impl(self._impl_obj.mainFrame)
 
-    @property
-    def frames(self) -> typing.List["Frame"]:
-        """Page.frames
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for_timeout(timeout=to_milliseconds(timeout))
+        )
 
-        An array of all frames attached to the page.
+    async def wait_for_function(
+        self,
+        expression: str,
+        *,
+        arg: typing.Optional[typing.Any] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None,
+    ) -> "JSHandle":
+        """Frame.wait_for_function
+
+        Returns when the `expression` returns a truthy value, returns that value.
+
+        **Usage**
+
+        The `frame.wait_for_function()` can be used to observe viewport size change:
+
+        ```py
+        import asyncio
+        from playwright.async_api import async_playwright, Playwright
+
+        async def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = await webkit.launch()
+            page = await browser.new_page()
+            await page.evaluate(\"window.x = 0; setTimeout(() => { window.x = 100 }, 1000);\")
+            await page.main_frame.wait_for_function(\"() => window.x > 0\")
+            await browser.close()
+
+        async def main():
+            async with async_playwright() as playwright:
+                await run(playwright)
+        asyncio.run(main())
+        ```
+
+        To pass an argument to the predicate of `frame.waitForFunction` function:
+
+        ```py
+        selector = \".foo\"
+        await frame.wait_for_function(\"selector => !!document.querySelector(selector)\", selector)
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()` or
+            `page.set_default_timeout()` methods.
+        polling : Union["raf", float, None]
+            If `polling` is `'raf'`, then `expression` is constantly executed in `requestAnimationFrame` callback. If `polling`
+            is a number, then it is treated as an interval in milliseconds at which the function would be executed. Defaults to
+            `raf`.
 
         Returns
         -------
-        List[Frame]
+        JSHandle
         """
-        return mapping.from_impl_list(self._impl_obj.frames)
 
-    @property
-    def url(self) -> str:
-        """Page.url
+        return mapping.from_impl(
+            await self._impl_obj.wait_for_function(
+                expression=expression,
+                arg=mapping.to_impl(arg),
+                timeout=to_milliseconds(timeout),
+                polling=polling,
+            )
+        )
 
-        Shortcut for main frame's frame.url().
+    async def title(self) -> str:
+        """Frame.title
+
+        Returns the page title.
 
         Returns
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.url)
 
-    @property
-    def workers(self) -> typing.List["Worker"]:
-        """Page.workers
+        return mapping.from_maybe_impl(await self._impl_obj.title())
 
-        This method returns all of the dedicated WebWorkers
-        associated with the page.
+    async def set_checked(
+        self,
+        selector: str,
+        checked: bool,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.set_checked
+
+        This method checks or unchecks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
-        **NOTE** This does not contain ServiceWorkers
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        checked : bool
+            Whether to check or uncheck the checkbox.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_checked(
+                selector=selector,
+                checked=checked,
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                trial=trial,
+            )
+        )
+
+
+mapping.register(FrameImpl, Frame)
+
+
+class FrameLocator(AsyncBase):
+
+    @property
+    def first(self) -> "FrameLocator":
+        """FrameLocator.first
+
+        Returns locator to the first matching frame.
 
         Returns
         -------
-        List[Worker]
+        FrameLocator
         """
-        return mapping.from_impl_list(self._impl_obj.workers)
+        return mapping.from_impl(self._impl_obj.first)
 
     @property
-    def video(self) -> typing.Union["Video", NoneType]:
-        """Page.video
+    def last(self) -> "FrameLocator":
+        """FrameLocator.last
 
-        Video object associated with this page.
+        Returns locator to the last matching frame.
 
         Returns
         -------
-        Optional[Video]
+        FrameLocator
         """
-        return mapping.from_impl_nullable(self._impl_obj.video)
+        return mapping.from_impl(self._impl_obj.last)
 
-    async def opener(self) -> typing.Union["Page", NoneType]:
-        """Page.opener
+    @property
+    def owner(self) -> "Locator":
+        """FrameLocator.owner
+
+        Returns a `Locator` object pointing to the same `iframe` as this frame locator.
 
-        Returns the opener for popup pages and `null` for others. If the opener has been closed already the promise may resolve
-        to `null`.
+        Useful when you have a `FrameLocator` object obtained somewhere, and later on would like to interact with the
+        `iframe` element.
+
+        For a reverse operation, use `locator.content_frame()`.
+
+        **Usage**
+
+        ```py
+        frame_locator = page.locator(\"iframe[name=\\\"embedded\\\"]\").content_frame
+        # ...
+        locator = frame_locator.owner
+        await expect(locator).to_be_visible()
+        ```
 
         Returns
         -------
-        Optional[Page]
+        Locator
         """
+        return mapping.from_impl(self._impl_obj.owner)
 
-        try:
-            log_api("=> page.opener started")
-            result = mapping.from_impl_nullable(await self._impl_obj.opener())
-            log_api("<= page.opener succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.opener failed")
-            raise e
-
-    def frame(
+    def locator(
         self,
-        name: str = None,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-    ) -> typing.Union["Frame", NoneType]:
-        """Page.frame
+        selector_or_locator: typing.Union["Locator", str],
+        *,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has: typing.Optional["Locator"] = None,
+        has_not: typing.Optional["Locator"] = None,
+    ) -> "Locator":
+        """FrameLocator.locator
 
-        Returns frame matching the specified criteria. Either `name` or `url` must be specified.
+        The method finds an element matching the specified selector in the locator's subtree. It also accepts filter
+        options, similar to `locator.filter()` method.
+
+        [Learn more about locators](https://playwright.dev/python/docs/locators).
 
         Parameters
         ----------
-        name : Optional[str]
-            frame name specified in the `iframe`'s `name` attribute
-        url : Union[str, Pattern, Callable[[str], bool], NoneType]
-            A glob pattern, regex pattern or predicate receiving frame's `url` as a URL object.
+        selector_or_locator : Union[Locator, str]
+            A selector or locator to use when resolving DOM element.
+        has_text : Union[Pattern[str], str, None]
+            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>`.
+        has_not_text : Union[Pattern[str], str, None]
+            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.
+        has : Union[Locator, None]
+            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`s.
+        has_not : Union[Locator, None]
+            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`s.
 
         Returns
         -------
-        Optional[Frame]
+        Locator
         """
 
-        try:
-            log_api("=> page.frame started")
-            result = mapping.from_impl_nullable(
-                self._impl_obj.frame(name=name, url=self._wrap_handler(url))
+        return mapping.from_impl(
+            self._impl_obj.locator(
+                selectorOrLocator=selector_or_locator,
+                hasText=has_text,
+                hasNotText=has_not_text,
+                has=has._impl_obj if has else None,
+                hasNot=has_not._impl_obj if has_not else None,
             )
-            log_api("<= page.frame succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.frame failed")
-            raise e
+        )
 
-    def set_default_navigation_timeout(self, timeout: int) -> NoneType:
-        """Page.set_default_navigation_timeout
+    def get_by_alt_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_alt_text
 
-        This setting will change the default maximum navigation time for the following methods and related shortcuts:
+        Allows locating elements by their alt text.
+
+        **Usage**
 
-        page.go_back([options])
-        page.go_forward([options])
-        page.goto(url[, options])
-        page.reload([options])
-        page.set_content(html[, options])
-        page.wait_for_navigation([options])
+        For example, this method will find the image by alt text \"Playwright logo\":
 
-        **NOTE** page.set_default_navigation_timeout(timeout) takes priority over page.set_default_timeout(timeout),
-        browser_context.set_default_timeout(timeout) and browser_context.set_default_navigation_timeout(timeout).
+        ```html
+        <img alt='Playwright logo'>
+        ```
+
+        ```py
+        await page.get_by_alt_text(\"Playwright logo\").click()
+        ```
 
         Parameters
         ----------
-        timeout : int
-            Maximum navigation time in milliseconds
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
         """
 
-        try:
-            log_api("=> page.set_default_navigation_timeout started")
-            result = mapping.from_maybe_impl(
-                self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
-            )
-            log_api("<= page.set_default_navigation_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_default_navigation_timeout failed")
-            raise e
+        return mapping.from_impl(self._impl_obj.get_by_alt_text(text=text, exact=exact))
 
-    def set_default_timeout(self, timeout: int) -> NoneType:
-        """Page.set_default_timeout
+    def get_by_label(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_label
+
+        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\">
+        ```
+
+        ```py
+        await page.get_by_label(\"Username\").fill(\"john\")
+        await page.get_by_label(\"Password\").fill(\"secret\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_label(text=text, exact=exact))
+
+    def get_by_placeholder(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_placeholder
+
+        Allows locating input elements by the placeholder text.
+
+        **Usage**
+
+        For example, consider the following DOM structure.
+
+        ```html
+        <input type=\"email\" placeholder=\"name@example.com\" />
+        ```
+
+        You can fill the input after locating it by the placeholder text:
+
+        ```py
+        await page.get_by_placeholder(\"name@example.com\").fill(\"playwright@microsoft.com\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_placeholder(text=text, exact=exact)
+        )
+
+    def get_by_role(
+        self,
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
+        ],
+        *,
+        checked: typing.Optional[bool] = None,
+        disabled: typing.Optional[bool] = None,
+        expanded: typing.Optional[bool] = None,
+        include_hidden: typing.Optional[bool] = None,
+        level: typing.Optional[int] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        pressed: typing.Optional[bool] = None,
+        selected: typing.Optional[bool] = None,
+        exact: typing.Optional[bool] = None,
+        description: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_role
+
+        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 its implicit role:
+
+        ```py
+        await expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
+
+        await page.get_by_role(\"checkbox\", name=\"Subscribe\").check()
+
+        await page.get_by_role(\"button\", name=re.compile(\"submit\", re.IGNORECASE)).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.
+
+        Parameters
+        ----------
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        checked : Union[bool, None]
+            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).
+        disabled : Union[bool, None]
+            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).
+
+        expanded : Union[bool, None]
+            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).
+        include_hidden : Union[bool, None]
+            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).
+        level : Union[int, None]
+            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).
+        name : Union[Pattern[str], str, None]
+            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` to control this behavior.
+
+            Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
+        pressed : Union[bool, None]
+            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).
+        selected : Union[bool, None]
+            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).
+        exact : Union[bool, None]
+            Whether `name` and `description` are matched exactly: case-sensitive and whole-string. Defaults to false. Ignored
+            when the value is a regular expression. Note that exact match still trims whitespace.
+        description : Union[Pattern[str], str, None]
+            Option to match the [accessible description](https://w3c.github.io/accname/#dfn-accessible-description). By
+            default, matching is case-insensitive and searches for a substring, use `exact` to control this behavior.
+
+            Learn more about [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_role(
+                role=role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=include_hidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
+
+    def get_by_test_id(
+        self, test_id: typing.Union[str, typing.Pattern[str]]
+    ) -> "Locator":
+        """FrameLocator.get_by_test_id
+
+        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 its test id:
+
+        ```py
+        await page.get_by_test_id(\"directions\").click()
+        ```
+
+        **Details**
+
+        By default, the `data-testid` attribute is used as a test id. Use `selectors.set_test_id_attribute()` to
+        configure a different test id attribute if necessary.
+
+        Parameters
+        ----------
+        test_id : Union[Pattern[str], str]
+            Id to locate the element by.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_test_id(testId=test_id))
+
+    def get_by_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_text
+
+        Allows locating elements that contain given text.
+
+        See also `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:
+
+        ```py
+        # Matches <span>
+        page.get_by_text(\"world\")
+
+        # Matches first <div>
+        page.get_by_text(\"Hello world\")
+
+        # Matches second <div>
+        page.get_by_text(\"Hello\", exact=True)
+
+        # Matches both <div>s
+        page.get_by_text(re.compile(\"Hello\"))
+
+        # Matches second <div>
+        page.get_by_text(re.compile(\"^hello$\", re.IGNORECASE))
+        ```
+
+        **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\">`.
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_text(text=text, exact=exact))
+
+    def get_by_title(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_title
+
+        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:
+
+        ```py
+        await expect(page.get_by_title(\"Issues count\")).to_have_text(\"25 issues\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_title(text=text, exact=exact))
+
+    def frame_locator(self, selector: str) -> "FrameLocator":
+        """FrameLocator.frame_locator
+
+        When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements
+        in that iframe.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to use when resolving DOM element.
+
+        Returns
+        -------
+        FrameLocator
+        """
+
+        return mapping.from_impl(self._impl_obj.frame_locator(selector=selector))
+
+    def nth(self, index: int) -> "FrameLocator":
+        """FrameLocator.nth
+
+        Returns locator to the n-th matching frame. It's zero based, `nth(0)` selects the first frame.
+
+        Parameters
+        ----------
+        index : int
+
+        Returns
+        -------
+        FrameLocator
+        """
+
+        return mapping.from_impl(self._impl_obj.nth(index=index))
+
+
+mapping.register(FrameLocatorImpl, FrameLocator)
+
+
+class Worker(AsyncBase):
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[["Worker"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is
+        terminated."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["console"],
+        f: typing.Callable[
+            ["ConsoleMessage"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when JavaScript within the worker calls one of console API methods, e.g. `console.log` or `console.dir`.
+        """
+
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[["Worker"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is
+        terminated."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["console"],
+        f: typing.Callable[
+            ["ConsoleMessage"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when JavaScript within the worker calls one of console API methods, e.g. `console.log` or `console.dir`.
+        """
+
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def url(self) -> str:
+        """Worker.url
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    async def evaluate(
+        self, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> typing.Any:
+        """Worker.evaluate
+
+        Returns the return value of `expression`.
+
+        If the function passed to the `worker.evaluate()` returns a [Promise], then `worker.evaluate()`
+        would wait for the promise to resolve and return its value.
+
+        If the function passed to the `worker.evaluate()` returns a non-[Serializable] value, then
+        `worker.evaluate()` returns `undefined`. Playwright also supports transferring some additional values that
+        are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.evaluate(
+                expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
+
+    async def evaluate_handle(
+        self, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> "JSHandle":
+        """Worker.evaluate_handle
+
+        Returns the return value of `expression` as a `JSHandle`.
+
+        The only difference between `worker.evaluate()` and `worker.evaluate_handle()` is that
+        `worker.evaluate_handle()` returns `JSHandle`.
+
+        If the function passed to the `worker.evaluate_handle()` returns a [Promise], then
+        `worker.evaluate_handle()` would wait for the promise to resolve and return its value.
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        JSHandle
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.evaluate_handle(
+                expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["ConsoleMessage"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager[typing.Any]: ...
+
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager:
+        """Worker.expect_event
+
+        Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+        value. Will throw an error if the page is closed before the event is fired. Returns the event data value.
+
+        **Usage**
+
+        ```py
+        async with worker.expect_event(\"console\") as event_info:
+            await worker.evaluate(\"console.log(42)\")
+        message = await event_info.value
+        ```
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_event(
+                event=event,
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+
+mapping.register(WorkerImpl, Worker)
+
+
+class Selectors(AsyncBase):
+
+    async def register(
+        self,
+        name: str,
+        script: typing.Optional[str] = None,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content_script: typing.Optional[bool] = None,
+    ) -> None:
+        """Selectors.register
+
+        Selectors must be registered before creating the page.
+
+        **Usage**
+
+        An example of registering selector engine that queries elements based on a tag name:
+
+        ```py
+        import asyncio
+        from playwright.async_api import async_playwright, Playwright
+
+        async def run(playwright: Playwright):
+            tag_selector = \"\"\"
+              {
+                  // 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 playwright.selectors.register(\"tag\", tag_selector)
+            browser = await playwright.chromium.launch()
+            page = await browser.new_page()
+            await page.set_content('<div><button>Click me</button></div>')
+
+            # Use the selector prefixed with its name.
+            button = await page.query_selector('tag=button')
+            # Combine it with built-in locators.
+            await page.locator('tag=div').get_by_text('Click me').click()
+            # Can use it in any methods supporting selectors.
+            button_count = await page.locator('tag=button').count()
+            print(button_count)
+            await browser.close()
+
+        async def main():
+            async with async_playwright() as playwright:
+                await run(playwright)
+
+        asyncio.run(main())
+        ```
+
+        Parameters
+        ----------
+        name : str
+            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.
+        script : Union[str, None]
+            Raw script content.
+        path : Union[pathlib.Path, str, None]
+            Path to the JavaScript file. If `path` is a relative path, then it is resolved relative to the current working
+            directory.
+        content_script : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.register(
+                name=name, script=script, path=path, contentScript=content_script
+            )
+        )
+
+    def set_test_id_attribute(self, attribute_name: str) -> None:
+        """Selectors.set_test_id_attribute
+
+        Defines custom attribute name to be used in `page.get_by_test_id()`. `data-testid` is used by default.
+
+        Parameters
+        ----------
+        attribute_name : str
+            Test id attribute name.
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_test_id_attribute(attributeName=attribute_name)
+        )
+
+
+mapping.register(SelectorsImpl, Selectors)
+
+
+class Clock(AsyncBase):
+
+    async def install(
+        self,
+        *,
+        time: typing.Optional[typing.Union[float, str, datetime.datetime]] = None,
+    ) -> None:
+        """Clock.install
+
+        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.run_for()` and
+        `clock.fast_forward()` for more information.
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str, None]
+            Time to initialize with, current system time by default.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.install(time=time))
+
+    async def fast_forward(self, ticks: typing.Union[int, str]) -> None:
+        """Clock.fast_forward
+
+        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**
+
+        ```py
+        await page.clock.fast_forward(1000)
+        await page.clock.fast_forward(\"30:00\")
+        ```
+
+        Parameters
+        ----------
+        ticks : Union[int, str]
+            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.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.fast_forward(ticks=ticks))
+
+    async def pause_at(self, time: typing.Union[float, str, datetime.datetime]) -> None:
+        """Clock.pause_at
+
+        Advance the clock by jumping forward in time and pause the time. Once this method is called, no timers are fired
+        unless `clock.run_for()`, `clock.fast_forward()`, `clock.pause_at()` or
+        `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**
+
+        ```py
+        await page.clock.pause_at(datetime.datetime(2020, 2, 2))
+        await page.clock.pause_at(\"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.pause_at()` to pause the clock.
+
+        ```py
+        # 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=datetime.datetime(2024, 12, 10, 8, 0, 0))
+        await page.goto(\"http://localhost:3333\")
+        await page.clock.pause_at(datetime.datetime(2024, 12, 10, 10, 0, 0))
+        ```
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str]
+            Time to pause at.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.pause_at(time=time))
+
+    async def resume(self) -> None:
+        """Clock.resume
+
+        Resumes timers. Once this method is called, time resumes flowing, timers are fired as usual.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.resume())
+
+    async def run_for(self, ticks: typing.Union[int, str]) -> None:
+        """Clock.run_for
+
+        Advance the clock, firing all the time-related callbacks.
+
+        **Usage**
+
+        ```py
+        await page.clock.run_for(1000);
+        await page.clock.run_for(\"30:00\")
+        ```
+
+        Parameters
+        ----------
+        ticks : Union[int, str]
+            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.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.run_for(ticks=ticks))
+
+    async def set_fixed_time(
+        self, time: typing.Union[float, str, datetime.datetime]
+    ) -> None:
+        """Clock.set_fixed_time
+
+        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()` instead. Read docs on [clock emulation](https://playwright.dev/python/docs/clock) to learn more.
+
+        **Usage**
+
+        ```py
+        await page.clock.set_fixed_time(datetime.datetime.now())
+        await page.clock.set_fixed_time(datetime.datetime(2020, 2, 2))
+        await page.clock.set_fixed_time(\"2020-02-02\")
+        ```
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str]
+            Time to be set.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.set_fixed_time(time=time))
+
+    async def set_system_time(
+        self, time: typing.Union[float, str, datetime.datetime]
+    ) -> None:
+        """Clock.set_system_time
+
+        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**
+
+        ```py
+        await page.clock.set_system_time(datetime.datetime.now())
+        await page.clock.set_system_time(datetime.datetime(2020, 2, 2))
+        await page.clock.set_system_time(\"2020-02-02\")
+        ```
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str]
+            Time to be set.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.set_system_time(time=time))
+
+
+mapping.register(ClockImpl, Clock)
+
+
+class ConsoleMessage(AsyncBase):
+
+    @property
+    def type(
+        self,
+    ) -> typing.Union[
+        Literal["assert"],
+        Literal["clear"],
+        Literal["count"],
+        Literal["debug"],
+        Literal["dir"],
+        Literal["dirxml"],
+        Literal["endGroup"],
+        Literal["error"],
+        Literal["info"],
+        Literal["log"],
+        Literal["profile"],
+        Literal["profileEnd"],
+        Literal["startGroup"],
+        Literal["startGroupCollapsed"],
+        Literal["table"],
+        Literal["time"],
+        Literal["timeEnd"],
+        Literal["trace"],
+        Literal["warning"],
+    ]:
+        """ConsoleMessage.type
+
+        Returns
+        -------
+        Union["assert", "clear", "count", "debug", "dir", "dirxml", "endGroup", "error", "info", "log", "profile", "profileEnd", "startGroup", "startGroupCollapsed", "table", "time", "timeEnd", "trace", "warning"]
+        """
+        return mapping.from_maybe_impl(self._impl_obj.type)
+
+    @property
+    def text(self) -> str:
+        """ConsoleMessage.text
+
+        The text of the console message.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.text)
+
+    @property
+    def args(self) -> typing.List["JSHandle"]:
+        """ConsoleMessage.args
+
+        List of arguments passed to a `console` function call. See also `page.on('console')`.
+
+        Returns
+        -------
+        List[JSHandle]
+        """
+        return mapping.from_impl_list(self._impl_obj.args)
+
+    @property
+    def location(self) -> SourceLocation:
+        """ConsoleMessage.location
+
+        Returns
+        -------
+        {url: str, line: int, column: int, lineNumber: int, columnNumber: int}
+        """
+        return mapping.from_impl(self._impl_obj.location)
+
+    @property
+    def timestamp(self) -> float:
+        """ConsoleMessage.timestamp
+
+        The timestamp of the console message in milliseconds since the Unix epoch.
+
+        Returns
+        -------
+        float
+        """
+        return mapping.from_maybe_impl(self._impl_obj.timestamp)
+
+    @property
+    def page(self) -> typing.Optional["Page"]:
+        """ConsoleMessage.page
+
+        The page that produced this console message, if any.
+
+        Returns
+        -------
+        Union[Page, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.page)
+
+    @property
+    def worker(self) -> typing.Optional["Worker"]:
+        """ConsoleMessage.worker
+
+        The web worker or service worker that produced this console message, if any. Note that console messages from web
+        workers also have non-null `console_message.page()`.
+
+        Returns
+        -------
+        Union[Worker, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.worker)
+
+
+mapping.register(ConsoleMessageImpl, ConsoleMessage)
+
+
+class Debugger(AsyncBase):
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["pausedstatechanged"],
+        f: typing.Callable[["None"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the debugger pauses or resumes."""
+
+    @typing.overload
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None: ...
+
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["pausedstatechanged"],
+        f: typing.Callable[["None"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the debugger pauses or resumes."""
+
+    @typing.overload
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None: ...
+
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def paused_details(self) -> typing.Optional[DebuggerPausedDetails]:
+        """Debugger.paused_details
+
+        Returns details about the currently paused call. Returns `null` if the debugger is not paused.
+
+        Returns
+        -------
+        Union[{location: {file: str, line: Union[int, None], column: Union[int, None]}, title: str}, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.paused_details)
+
+    async def request_pause(self) -> None:
+        """Debugger.request_pause
+
+        Configures the debugger to pause before the next action is executed.
+
+        Throws if the debugger is already paused. Use `debugger.next()` or `debugger.run_to()` to step while
+        paused.
+
+        Note that `page.pause()` is equivalent to a \"debugger\" statement — it pauses execution at the call site
+        immediately. On the contrary, `debugger.request_pause()` is equivalent to \"pause on next statement\" — it
+        configures the debugger to pause before the next action is executed.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.request_pause())
+
+    async def resume(self) -> None:
+        """Debugger.resume
+
+        Resumes script execution. Throws if the debugger is not paused.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.resume())
+
+    async def next(self) -> None:
+        """Debugger.next
+
+        Resumes script execution and pauses again before the next action. Throws if the debugger is not paused.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.next())
+
+    async def run_to(self, location: DebuggerLocation) -> None:
+        """Debugger.run_to
+
+        Resumes script execution and pauses when an action originates from the given source location. Throws if the
+        debugger is not paused.
+
+        Parameters
+        ----------
+        location : {file: str, line: Union[int, None], column: Union[int, None]}
+            The source location to pause at.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.run_to(location=location))
+
+
+mapping.register(DebuggerImpl, Debugger)
+
+
+class Dialog(AsyncBase):
+
+    @property
+    def type(self) -> str:
+        """Dialog.type
+
+        Returns dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.type)
+
+    @property
+    def message(self) -> str:
+        """Dialog.message
+
+        A message displayed in the dialog.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.message)
+
+    @property
+    def default_value(self) -> str:
+        """Dialog.default_value
+
+        If dialog is prompt, returns default prompt value. Otherwise, returns empty string.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.default_value)
+
+    @property
+    def page(self) -> typing.Optional["Page"]:
+        """Dialog.page
+
+        The page that initiated this dialog, if available.
+
+        Returns
+        -------
+        Union[Page, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.page)
+
+    async def accept(self, prompt_text: typing.Optional[str] = None) -> None:
+        """Dialog.accept
+
+        Returns when the dialog has been accepted.
+
+        Parameters
+        ----------
+        prompt_text : Union[str, None]
+            A text to enter in prompt. Does not cause any effects if the dialog's `type` is not prompt. Optional.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.accept(promptText=prompt_text)
+        )
+
+    async def dismiss(self) -> None:
+        """Dialog.dismiss
+
+        Returns when the dialog has been dismissed.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.dismiss())
+
+
+mapping.register(DialogImpl, Dialog)
+
+
+class Download(AsyncBase):
+
+    @property
+    def page(self) -> "Page":
+        """Download.page
+
+        Get the page that the download belongs to.
+
+        Returns
+        -------
+        Page
+        """
+        return mapping.from_impl(self._impl_obj.page)
+
+    @property
+    def url(self) -> str:
+        """Download.url
+
+        Returns downloaded url.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    @property
+    def suggested_filename(self) -> str:
+        """Download.suggested_filename
+
+        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.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.suggested_filename)
+
+    async def delete(self) -> None:
+        """Download.delete
+
+        Deletes the downloaded file. Will wait for the download to finish if necessary.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.delete())
+
+    async def failure(self) -> typing.Optional[str]:
+        """Download.failure
+
+        Returns download error if any. Will wait for the download to finish if necessary.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.failure())
+
+    async def path(self) -> pathlib.Path:
+        """Download.path
+
+        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.suggested_filename()` to get suggested
+        file name.
+
+        Returns
+        -------
+        pathlib.Path
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.path())
+
+    async def save_as(self, path: typing.Union[str, pathlib.Path]) -> None:
+        """Download.save_as
+
+        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**
+
+        ```py
+        await download.save_as(\"/path/to/save/at/\" + download.suggested_filename)
+        ```
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str]
+            Path where the download should be copied.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.save_as(path=path))
+
+    async def cancel(self) -> None:
+        """Download.cancel
+
+        Cancels a download. Will not fail if the download is already finished or canceled. Upon successful cancellations,
+        `download.failure()` would resolve to `'canceled'`.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.cancel())
+
+
+mapping.register(DownloadImpl, Download)
+
+
+class Screencast(AsyncBase):
+
+    async def start(
+        self,
+        *,
+        on_frame: typing.Optional[
+            typing.Callable[[ScreencastFrame], typing.Any]
+        ] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+    ) -> "AsyncContextManager":
+        """Screencast.start
+
+        Starts the screencast. When `path` is provided, it saves video recording to the specified file. When `onFrame` is
+        provided, delivers JPEG-encoded frames to the callback. Both can be used together.
+
+        **Usage**
+
+        Parameters
+        ----------
+        on_frame : Union[Callable[[{data: bytes, viewportWidth: int, viewportHeight: int}], Any], None]
+            Callback that receives JPEG-encoded frame data along with the page viewport size at the time of capture.
+        path : Union[pathlib.Path, str, None]
+            Path where the video should be saved when the screencast is stopped. When provided, video recording is started.
+        quality : Union[int, None]
+            The quality of the image, between 0-100.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.start(
+                onFrame=self._wrap_handler(on_frame), path=path, quality=quality
+            )
+        )
+
+    async def stop(self) -> None:
+        """Screencast.stop
+
+        Stops the screencast and video recording if active. If a video was being recorded, saves it to the path specified
+        in `screencast.start()`.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.stop())
+
+    async def show_actions(
+        self,
+        *,
+        duration: typing.Optional[float] = None,
+        position: typing.Optional[
+            Literal[
+                "bottom", "bottom-left", "bottom-right", "top", "top-left", "top-right"
+            ]
+        ] = None,
+        font_size: typing.Optional[int] = None,
+    ) -> "AsyncContextManager":
+        """Screencast.show_actions
+
+        Enables visual annotations on interacted elements. Returns a disposable that stops showing actions when disposed.
+
+        Parameters
+        ----------
+        duration : Union[float, None]
+            How long each annotation is displayed in milliseconds. Defaults to `500`.
+        position : Union["bottom", "bottom-left", "bottom-right", "top", "top-left", "top-right", None]
+            Position of the action title overlay. Defaults to `"top-right"`.
+        font_size : Union[int, None]
+            Font size of the action title in pixels. Defaults to `24`.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.show_actions(
+                duration=duration, position=position, fontSize=font_size
+            )
+        )
+
+    async def hide_actions(self) -> None:
+        """Screencast.hide_actions
+
+        Removes action decorations.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.hide_actions())
+
+    async def show_overlay(
+        self, html: str, *, duration: typing.Optional[float] = None
+    ) -> "AsyncContextManager":
+        """Screencast.show_overlay
+
+        Adds an overlay with the given HTML content. The overlay is displayed on top of the page until removed. Returns a
+        disposable that removes the overlay when disposed.
+
+        Parameters
+        ----------
+        html : str
+            HTML content for the overlay.
+        duration : Union[float, None]
+            Duration in milliseconds after which the overlay is automatically removed. Overlay stays until dismissed if not
+            provided.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.show_overlay(html=html, duration=duration)
+        )
+
+    async def show_chapter(
+        self,
+        title: str,
+        *,
+        description: typing.Optional[str] = None,
+        duration: typing.Optional[float] = None,
+    ) -> None:
+        """Screencast.show_chapter
+
+        Shows a chapter overlay with a title and optional description, centered on the page with a blurred backdrop. Useful
+        for narrating video recordings. The overlay is removed after the specified duration, or 2000ms.
+
+        Parameters
+        ----------
+        title : str
+            Title text displayed prominently in the overlay.
+        description : Union[str, None]
+            Optional description text displayed below the title.
+        duration : Union[float, None]
+            Duration in milliseconds after which the overlay is automatically removed. Defaults to `2000`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.show_chapter(
+                title=title, description=description, duration=duration
+            )
+        )
+
+    async def show_overlays(self) -> None:
+        """Screencast.show_overlays
+
+        Shows overlays.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.show_overlays())
+
+    async def hide_overlays(self) -> None:
+        """Screencast.hide_overlays
+
+        Hides overlays without removing them.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.hide_overlays())
+
+
+mapping.register(ScreencastImpl, Screencast)
+
+
+class Video(AsyncBase):
+
+    async def path(self) -> pathlib.Path:
+        """Video.path
+
+        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.
+
+        Returns
+        -------
+        pathlib.Path
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.path())
+
+    async def save_as(self, path: typing.Union[str, pathlib.Path]) -> None:
+        """Video.save_as
+
+        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.
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str]
+            Path where the video should be saved.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.save_as(path=path))
+
+    async def delete(self) -> None:
+        """Video.delete
+
+        Deletes the video file. Will wait for the video to finish if necessary.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.delete())
+
+
+mapping.register(VideoImpl, Video)
+
+
+class Page(AsyncContextManager):
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the page closes."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["console"],
+        f: typing.Callable[
+            ["ConsoleMessage"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        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` event handler argument.
+
+        **Usage**
+
+        ```py
+        async def print_args(msg):
+            values = []
+            for arg in msg.args:
+                values.append(await arg.json_value())
+            print(values)
+
+        page.on(\"console\", print_args)
+        await page.evaluate(\"console.log('hello', 5, { foo: 'bar' })\")
+        ```"""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["crash"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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:
+
+        ```py
+        try:
+            # crash might happen during a click.
+            await page.click(\"button\")
+            # or while waiting for an event.
+            await page.wait_for_event(\"popup\")
+        except Error as e:
+            pass
+            # when the page crashes, exception message contains \"crash\".
+        ```"""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["dialog"],
+        f: typing.Callable[["Dialog"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**
+        either `dialog.accept()` or `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**
+
+        ```python
+        page.on(\"dialog\", lambda dialog: dialog.accept())
+        ```
+
+        **NOTE** When no `page.on('dialog')` or `browser_context.on('dialog')` listeners are present, all dialogs are
+        automatically dismissed."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["domcontentloaded"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the JavaScript
+        [`DOMContentLoaded`](https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded) event is dispatched.
+        """
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["download"],
+        f: typing.Callable[["Download"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when attachment download started. User can access basic file operations on downloaded content via the
+        passed `Download` instance."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["filechooser"],
+        f: typing.Callable[
+            ["FileChooser"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        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 `file_chooser.set_files()` that can be uploaded after that.
+
+        ```py
+        page.on(\"filechooser\", lambda file_chooser: file_chooser.set_files(\"/tmp/myfile.pdf\"))
+        ```"""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["frameattached"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is attached."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["framedetached"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is detached."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["framenavigated"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is navigated to a new url."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["load"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched.
+        """
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["pageerror"],
+        f: typing.Callable[["Error"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when an uncaught exception happens within the page.
+
+        ```py
+        # Log all uncaught errors to the terminal
+        page.on(\"pageerror\", lambda exc: print(f\"uncaught exception: {exc}\"))
+
+        # Navigate to a page with an exception.
+        await page.goto(\"data:text/html,<script>throw new Error('test')</script>\")
+        ```"""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["popup"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the page opens a new tab or window. This event is emitted in addition to the
+        `browser_context.on('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 `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
+
+        ```py
+        async with page.expect_event(\"popup\") as page_info:
+            await page.get_by_text(\"open the popup\").click()
+        popup = await page_info.value
+        print(await popup.evaluate(\"location.href\"))
+        ```
+
+        **NOTE** Use `page.wait_for_load_state()` to wait until the page gets to a particular state (you should not
+        need it in most cases)."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["request"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a page issues a request. The [request] object is read-only. In order to intercept and mutate requests,
+        see `page.route()` or `browser_context.route()`."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["requestfailed"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a request fails, for example by timing out.
+
+        ```python
+        page.on(\"requestfailed\", lambda request: print(request.url + \" \" + request.failure.error_text))
+        ```
+
+        **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request
+        will complete with `page.on('request_finished')` event and not with `page.on('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."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["requestfinished"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a request finishes successfully after downloading the response body. For a successful response, the
+        sequence of events is `request`, `response` and `requestfinished`."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["response"],
+        f: typing.Callable[["Response"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when [response] status and headers are received for a request. For a successful response, the sequence of
+        events is `request`, `response` and `requestfinished`."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["websocket"],
+        f: typing.Callable[["WebSocket"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when `WebSocket` request is sent."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["worker"],
+        f: typing.Callable[["Worker"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned
+        by the page."""
+
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the page closes."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["console"],
+        f: typing.Callable[
+            ["ConsoleMessage"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        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` event handler argument.
+
+        **Usage**
+
+        ```py
+        async def print_args(msg):
+            values = []
+            for arg in msg.args:
+                values.append(await arg.json_value())
+            print(values)
+
+        page.on(\"console\", print_args)
+        await page.evaluate(\"console.log('hello', 5, { foo: 'bar' })\")
+        ```"""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["crash"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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:
+
+        ```py
+        try:
+            # crash might happen during a click.
+            await page.click(\"button\")
+            # or while waiting for an event.
+            await page.wait_for_event(\"popup\")
+        except Error as e:
+            pass
+            # when the page crashes, exception message contains \"crash\".
+        ```"""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["dialog"],
+        f: typing.Callable[["Dialog"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**
+        either `dialog.accept()` or `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**
+
+        ```python
+        page.on(\"dialog\", lambda dialog: dialog.accept())
+        ```
+
+        **NOTE** When no `page.on('dialog')` or `browser_context.on('dialog')` listeners are present, all dialogs are
+        automatically dismissed."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["domcontentloaded"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the JavaScript
+        [`DOMContentLoaded`](https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded) event is dispatched.
+        """
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["download"],
+        f: typing.Callable[["Download"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when attachment download started. User can access basic file operations on downloaded content via the
+        passed `Download` instance."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["filechooser"],
+        f: typing.Callable[
+            ["FileChooser"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        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 `file_chooser.set_files()` that can be uploaded after that.
+
+        ```py
+        page.on(\"filechooser\", lambda file_chooser: file_chooser.set_files(\"/tmp/myfile.pdf\"))
+        ```"""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["frameattached"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is attached."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["framedetached"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is detached."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["framenavigated"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is navigated to a new url."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["load"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched.
+        """
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["pageerror"],
+        f: typing.Callable[["Error"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when an uncaught exception happens within the page.
+
+        ```py
+        # Log all uncaught errors to the terminal
+        page.on(\"pageerror\", lambda exc: print(f\"uncaught exception: {exc}\"))
+
+        # Navigate to a page with an exception.
+        await page.goto(\"data:text/html,<script>throw new Error('test')</script>\")
+        ```"""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["popup"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the page opens a new tab or window. This event is emitted in addition to the
+        `browser_context.on('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 `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
+
+        ```py
+        async with page.expect_event(\"popup\") as page_info:
+            await page.get_by_text(\"open the popup\").click()
+        popup = await page_info.value
+        print(await popup.evaluate(\"location.href\"))
+        ```
+
+        **NOTE** Use `page.wait_for_load_state()` to wait until the page gets to a particular state (you should not
+        need it in most cases)."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["request"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a page issues a request. The [request] object is read-only. In order to intercept and mutate requests,
+        see `page.route()` or `browser_context.route()`."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["requestfailed"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a request fails, for example by timing out.
+
+        ```python
+        page.on(\"requestfailed\", lambda request: print(request.url + \" \" + request.failure.error_text))
+        ```
+
+        **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request
+        will complete with `page.on('request_finished')` event and not with `page.on('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."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["requestfinished"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a request finishes successfully after downloading the response body. For a successful response, the
+        sequence of events is `request`, `response` and `requestfinished`."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["response"],
+        f: typing.Callable[["Response"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when [response] status and headers are received for a request. For a successful response, the sequence of
+        events is `request`, `response` and `requestfinished`."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["websocket"],
+        f: typing.Callable[["WebSocket"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when `WebSocket` request is sent."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["worker"],
+        f: typing.Callable[["Worker"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned
+        by the page."""
+
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def keyboard(self) -> "Keyboard":
+        """Page.keyboard
+
+        Returns
+        -------
+        Keyboard
+        """
+        return mapping.from_impl(self._impl_obj.keyboard)
+
+    @property
+    def mouse(self) -> "Mouse":
+        """Page.mouse
+
+        Returns
+        -------
+        Mouse
+        """
+        return mapping.from_impl(self._impl_obj.mouse)
+
+    @property
+    def touchscreen(self) -> "Touchscreen":
+        """Page.touchscreen
+
+        Returns
+        -------
+        Touchscreen
+        """
+        return mapping.from_impl(self._impl_obj.touchscreen)
+
+    @property
+    def context(self) -> "BrowserContext":
+        """Page.context
+
+        Get the browser context that the page belongs to.
+
+        Returns
+        -------
+        BrowserContext
+        """
+        return mapping.from_impl(self._impl_obj.context)
+
+    @property
+    def clock(self) -> "Clock":
+        """Page.clock
+
+        Playwright has ability to mock clock and passage of time.
+
+        Returns
+        -------
+        Clock
+        """
+        return mapping.from_impl(self._impl_obj.clock)
+
+    @property
+    def main_frame(self) -> "Frame":
+        """Page.main_frame
+
+        The page's main frame. Page is guaranteed to have a main frame which persists during navigations.
+
+        Returns
+        -------
+        Frame
+        """
+        return mapping.from_impl(self._impl_obj.main_frame)
+
+    @property
+    def frames(self) -> typing.List["Frame"]:
+        """Page.frames
+
+        An array of all frames attached to the page.
+
+        Returns
+        -------
+        List[Frame]
+        """
+        return mapping.from_impl_list(self._impl_obj.frames)
+
+    @property
+    def url(self) -> str:
+        """Page.url
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    @property
+    def viewport_size(self) -> typing.Optional[ViewportSize]:
+        """Page.viewport_size
+
+        Returns
+        -------
+        Union[{width: int, height: int}, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.viewport_size)
+
+    @property
+    def workers(self) -> typing.List["Worker"]:
+        """Page.workers
+
+        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
+
+        Returns
+        -------
+        List[Worker]
+        """
+        return mapping.from_impl_list(self._impl_obj.workers)
+
+    @property
+    def request(self) -> "APIRequestContext":
+        """Page.request
+
+        API testing helper associated with this page. This method returns the same instance as
+        `browser_context.request` on the page's context. See `browser_context.request` for more
+        details.
+
+        Returns
+        -------
+        APIRequestContext
+        """
+        return mapping.from_impl(self._impl_obj.request)
+
+    @property
+    def video(self) -> typing.Optional["Video"]:
+        """Page.video
+
+        Video object associated with this page. Can be used to access the video file when using the `recordVideo` context
+        option.
+
+        Returns
+        -------
+        Union[Video, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.video)
+
+    @property
+    def screencast(self) -> "Screencast":
+        """Page.screencast
+
+        `Screencast` object associated with this page.
+
+        **Usage**
+
+        Returns
+        -------
+        Screencast
+        """
+        return mapping.from_impl(self._impl_obj.screencast)
+
+    async def opener(self) -> typing.Optional["Page"]:
+        """Page.opener
+
+        Returns the opener for popup pages and `null` for others. If the opener has been closed already the returns `null`.
+
+        Returns
+        -------
+        Union[Page, None]
+        """
+
+        return mapping.from_impl_nullable(await self._impl_obj.opener())
+
+    def frame(
+        self,
+        name: typing.Optional[str] = None,
+        *,
+        url: typing.Optional[
+            typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]]
+        ] = None,
+    ) -> typing.Optional["Frame"]:
+        """Page.frame
+
+        Returns frame matching the specified criteria. Either `name` or `url` must be specified.
+
+        **Usage**
+
+        ```py
+        frame = page.frame(name=\"frame-name\")
+        ```
+
+        Parameters
+        ----------
+        name : Union[str, None]
+            Frame name specified in the `iframe`'s `name` attribute. Optional.
+        url : Union[Callable[[str], bool], Pattern[str], str, None]
+            A glob pattern, regex pattern or predicate receiving frame's `url` as a [URL] object. Optional.
+
+        Returns
+        -------
+        Union[Frame, None]
+        """
+
+        return mapping.from_impl_nullable(
+            self._impl_obj.frame(name=name, url=self._wrap_handler(url))
+        )
+
+    def set_default_navigation_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """Page.set_default_navigation_timeout
+
+        This setting will change the default maximum navigation time for the following methods and related shortcuts:
+        - `page.go_back()`
+        - `page.go_forward()`
+        - `page.goto()`
+        - `page.reload()`
+        - `page.set_content()`
+        - `page.expect_navigation()`
+        - `page.wait_for_url()`
+
+        **NOTE** `page.set_default_navigation_timeout()` takes priority over `page.set_default_timeout()`,
+        `browser_context.set_default_timeout()` and `browser_context.set_default_navigation_timeout()`.
+
+        Parameters
+        ----------
+        timeout : float
+            Maximum navigation time in milliseconds
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_default_navigation_timeout(
+                timeout=to_milliseconds(timeout)
+            )
+        )
+
+    def set_default_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """Page.set_default_timeout
+
+        This setting will change the default maximum time for all the methods accepting `timeout` option.
+
+        **NOTE** `page.set_default_navigation_timeout()` takes priority over `page.set_default_timeout()`.
+
+        Parameters
+        ----------
+        timeout : float
+            Maximum time in milliseconds. Pass `0` to disable timeout.
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_default_timeout(timeout=to_milliseconds(timeout))
+        )
+
+    async def query_selector(
+        self, selector: str, *, strict: typing.Optional[bool] = None
+    ) -> typing.Optional["ElementHandle"]:
+        """Page.query_selector
+
+        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.wait_for()`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        strict : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Union[ElementHandle, None]
+        """
+
+        return mapping.from_impl_nullable(
+            await self._impl_obj.query_selector(selector=selector, strict=strict)
+        )
+
+    async def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
+        """Page.query_selector_all
+
+        The method finds all elements matching the specified selector within the page. If no elements match the selector,
+        the return value resolves to `[]`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+
+        Returns
+        -------
+        List[ElementHandle]
+        """
+
+        return mapping.from_impl_list(
+            await self._impl_obj.query_selector_all(selector=selector)
+        )
+
+    async def wait_for_selector(
+        self,
+        selector: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        state: typing.Optional[
+            Literal["attached", "detached", "hidden", "visible"]
+        ] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> typing.Optional["ElementHandle"]:
+        """Page.wait_for_selector
+
+        Returns when element specified by selector satisfies `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`
+        objects and web-first assertions makes the code wait-for-selector-free.
+
+        Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If
+        at the moment of calling the method `selector` already satisfies the condition, the method will return immediately.
+        If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
+
+        **Usage**
+
+        This method works across navigations:
+
+        ```py
+        import asyncio
+        from playwright.async_api import async_playwright, Playwright
+
+        async def run(playwright: Playwright):
+            chromium = playwright.chromium
+            browser = await chromium.launch()
+            page = await browser.new_page()
+            for current_url in [\"https://google.com\", \"https://bbc.com\"]:
+                await page.goto(current_url, wait_until=\"domcontentloaded\")
+                element = await page.wait_for_selector(\"img\")
+                print(\"Loaded image: \" + str(await element.get_attribute(\"src\")))
+            await browser.close()
+
+        async def main():
+            async with async_playwright() as playwright:
+                await run(playwright)
+        asyncio.run(main())
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        state : Union["attached", "detached", "hidden", "visible", None]
+            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.
+        strict : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Union[ElementHandle, None]
+        """
+
+        return mapping.from_impl_nullable(
+            await self._impl_obj.wait_for_selector(
+                selector=selector,
+                timeout=to_milliseconds(timeout),
+                state=state,
+                strict=strict,
+            )
+        )
+
+    async def is_checked(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_checked
+
+        Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_checked(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def is_disabled(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_disabled
+
+        Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability#enabled).
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_disabled(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def is_editable(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_editable
+
+        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_editable(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def is_enabled(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_enabled
+
+        Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_enabled(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def is_hidden(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_hidden
+
+        Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability#visible).  `selector` that
+        does not match any elements is considered hidden.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Deprecated: This option is ignored. `page.is_hidden()` does not wait for the↵element to become hidden and returns immediately.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_hidden(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def is_visible(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_visible
+
+        Returns whether the element is [visible](https://playwright.dev/python/docs/actionability#visible). `selector` that does not match any elements
+        is considered not visible.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Deprecated: This option is ignored. `page.is_visible()` does not wait↵for the element to become visible and returns immediately.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_visible(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def dispatch_event(
+        self,
+        selector: str,
+        type: str,
+        event_init: typing.Optional[typing.Dict] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.dispatch_event
+
+        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**
+
+        ```py
+        await page.dispatch_event(\"button#submit\", \"click\")
+        ```
+
+        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit`
+        properties and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
+
+        Since `eventInit` 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:
+
+        ```py
+        # note you can only create data_transfer in chromium and firefox
+        data_transfer = await page.evaluate_handle(\"new DataTransfer()\")
+        await page.dispatch_event(\"#source\", \"dragstart\", { \"dataTransfer\": data_transfer })
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        type : str
+            DOM event type: `"click"`, `"dragstart"`, etc.
+        event_init : Union[Dict, None]
+            Optional event-specific initialization properties.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        strict : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.dispatch_event(
+                selector=selector,
+                type=type,
+                eventInit=mapping.to_impl(event_init),
+                timeout=to_milliseconds(timeout),
+                strict=strict,
+            )
+        )
+
+    async def evaluate(
+        self, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> typing.Any:
+        """Page.evaluate
+
+        Returns the value of the `expression` invocation.
+
+        If the function passed to the `page.evaluate()` returns a [Promise], then `page.evaluate()` would
+        wait for the promise to resolve and return its value.
+
+        If the function passed to the `page.evaluate()` returns a non-[Serializable] value, then
+        `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 `expression`:
+
+        ```py
+        result = await page.evaluate(\"([x, y]) => Promise.resolve(x * y)\", [7, 8])
+        print(result) # prints \"56\"
+        ```
+
+        A string can also be passed in instead of a function:
+
+        ```py
+        print(await page.evaluate(\"1 + 2\")) # prints \"3\"
+        x = 10
+        print(await page.evaluate(f\"1 + {x}\")) # prints \"11\"
+        ```
+
+        `ElementHandle` instances can be passed as an argument to the `page.evaluate()`:
+
+        ```py
+        body_handle = await page.evaluate(\"document.body\")
+        html = await page.evaluate(\"([body, suffix]) => body.innerHTML + suffix\", [body_handle, \"hello\"])
+        await body_handle.dispose()
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.evaluate(
+                expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
+
+    async def evaluate_handle(
+        self, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> "JSHandle":
+        """Page.evaluate_handle
+
+        Returns the value of the `expression` invocation as a `JSHandle`.
+
+        The only difference between `page.evaluate()` and `page.evaluate_handle()` is that
+        `page.evaluate_handle()` returns `JSHandle`.
+
+        If the function passed to the `page.evaluate_handle()` returns a [Promise], then
+        `page.evaluate_handle()` would wait for the promise to resolve and return its value.
+
+        **Usage**
+
+        ```py
+        a_window_handle = await page.evaluate_handle(\"Promise.resolve(window)\")
+        a_window_handle # handle for the window object.
+        ```
+
+        A string can also be passed in instead of a function:
+
+        ```py
+        a_handle = await page.evaluate_handle(\"document\") # handle for the \"document\"
+        ```
+
+        `JSHandle` instances can be passed as an argument to the `page.evaluate_handle()`:
+
+        ```py
+        a_handle = await page.evaluate_handle(\"document.body\")
+        result_handle = await page.evaluate_handle(\"body => body.innerHTML\", a_handle)
+        print(await result_handle.json_value())
+        await result_handle.dispose()
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        JSHandle
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.evaluate_handle(
+                expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
+
+    async def eval_on_selector(
+        self,
+        selector: str,
+        expression: str,
+        arg: typing.Optional[typing.Any] = None,
+        *,
+        strict: typing.Optional[bool] = None,
+    ) -> typing.Any:
+        """Page.eval_on_selector
+
+        The method finds an element matching the specified selector within the page and passes it as a first argument to
+        `expression`. If no elements match the selector, the method throws an error. Returns the value of `expression`.
+
+        If `expression` returns a [Promise], then `page.eval_on_selector()` would wait for the promise to resolve and
+        return its value.
+
+        **Usage**
+
+        ```py
+        search_value = await page.eval_on_selector(\"#search\", \"el => el.value\")
+        preload_href = await page.eval_on_selector(\"link[rel=preload]\", \"el => el.href\")
+        html = await page.eval_on_selector(\".main-container\", \"(e, suffix) => e.outer_html + suffix\", \"hello\")
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        strict : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.eval_on_selector(
+                selector=selector,
+                expression=expression,
+                arg=mapping.to_impl(arg),
+                strict=strict,
+            )
+        )
+
+    async def eval_on_selector_all(
+        self, selector: str, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> typing.Any:
+        """Page.eval_on_selector_all
+
+        The method finds all elements matching the specified selector within the page and passes an array of matched
+        elements as a first argument to `expression`. Returns the result of `expression` invocation.
+
+        If `expression` returns a [Promise], then `page.eval_on_selector_all()` would wait for the promise to resolve
+        and return its value.
+
+        **Usage**
+
+        ```py
+        div_counts = await page.eval_on_selector_all(\"div\", \"(divs, min) => divs.length >= min\", 10)
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.eval_on_selector_all(
+                selector=selector, expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
+
+    async def add_script_tag(
+        self,
+        *,
+        url: typing.Optional[str] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
+        type: typing.Optional[str] = None,
+    ) -> "ElementHandle":
+        """Page.add_script_tag
+
+        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.
+
+        Parameters
+        ----------
+        url : Union[str, None]
+            URL of a script to be added.
+        path : Union[pathlib.Path, str, None]
+            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.
+        content : Union[str, None]
+            Raw JavaScript content to be injected into frame.
+        type : Union[str, None]
+            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.
+
+        Returns
+        -------
+        ElementHandle
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.add_script_tag(
+                url=url, path=path, content=content, type=type
+            )
+        )
+
+    async def add_style_tag(
+        self,
+        *,
+        url: typing.Optional[str] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
+    ) -> "ElementHandle":
+        """Page.add_style_tag
+
+        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.
+
+        Parameters
+        ----------
+        url : Union[str, None]
+            URL of the `<link>` tag.
+        path : Union[pathlib.Path, str, None]
+            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.
+        content : Union[str, None]
+            Raw CSS content to be injected into frame.
+
+        Returns
+        -------
+        ElementHandle
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.add_style_tag(url=url, path=path, content=content)
+        )
+
+    async def expose_function(
+        self, name: str, callback: typing.Callable
+    ) -> "AsyncContextManager":
+        """Page.expose_function
+
+        The method adds a function called `name` on the `window` object of every frame in the page. When called, the
+        function executes `callback` and returns a [Promise] which resolves to the return value of `callback`.
+
+        If the `callback` returns a [Promise], it will be awaited.
+
+        See `browser_context.expose_function()` for context-wide exposed function.
+
+        **NOTE** Functions installed via `page.expose_function()` survive navigations.
+
+        **Usage**
+
+        An example of adding a `sha256` function to the page:
+
+        ```py
+        import asyncio
+        import hashlib
+        from playwright.async_api import async_playwright, Playwright
+
+        def sha256(text):
+            m = hashlib.sha256()
+            m.update(bytes(text, \"utf8\"))
+            return m.hexdigest()
+
+        async def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = await webkit.launch(headless=False)
+            page = await browser.new_page()
+            await page.expose_function(\"sha256\", sha256)
+            await page.set_content(\"\"\"
+                <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\")
+
+        async def main():
+            async with async_playwright() as playwright:
+                await run(playwright)
+        asyncio.run(main())
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Name of the function on the window object
+        callback : Callable
+            Callback function which will be called in Playwright's context.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.expose_function(
+                name=name, callback=self._wrap_handler(callback)
+            )
+        )
+
+    async def expose_binding(
+        self, name: str, callback: typing.Callable
+    ) -> "AsyncContextManager":
+        """Page.expose_binding
+
+        The method adds a function called `name` on the `window` object of every frame in this page. When called, the
+        function executes `callback` and returns a [Promise] which resolves to the return value of `callback`. If the
+        `callback` returns a [Promise], it will be awaited.
+
+        The first argument of the `callback` function contains information about the caller: `{ browserContext:
+        BrowserContext, page: Page, frame: Frame }`.
+
+        See `browser_context.expose_binding()` for the context-wide version.
+
+        **NOTE** Functions installed via `page.expose_binding()` survive navigations.
+
+        **Usage**
+
+        An example of exposing page URL to all frames in a page:
+
+        ```py
+        import asyncio
+        from playwright.async_api import async_playwright, Playwright
+
+        async def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = await webkit.launch(headless=False)
+            context = await browser.new_context()
+            page = await context.new_page()
+            await page.expose_binding(\"pageURL\", lambda source: source[\"page\"].url)
+            await page.set_content(\"\"\"
+            <script>
+              async function onClick() {
+                document.querySelector('div').textContent = await window.pageURL();
+              }
+            </script>
+            <button onclick=\"onClick()\">Click me</button>
+            <div></div>
+            \"\"\")
+            await page.click(\"button\")
+
+        async def main():
+            async with async_playwright() as playwright:
+                await run(playwright)
+        asyncio.run(main())
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Name of the function on the window object.
+        callback : Callable
+            Callback function that will be called in the Playwright's context.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.expose_binding(
+                name=name, callback=self._wrap_handler(callback)
+            )
+        )
+
+    async def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> None:
+        """Page.set_extra_http_headers
+
+        The extra HTTP headers will be sent with every request the page initiates.
+
+        **NOTE** `page.set_extra_http_headers()` does not guarantee the order of headers in the outgoing requests.
+
+        Parameters
+        ----------
+        headers : Dict[str, str]
+            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_extra_http_headers(
+                headers=mapping.to_impl(headers)
+            )
+        )
+
+    async def content(self) -> str:
+        """Page.content
+
+        Gets the full HTML contents of the page, including the doctype.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.content())
+
+    async def set_content(
+        self,
+        html: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> None:
+        """Page.set_content
+
+        This method internally calls [document.write()](https://developer.mozilla.org/en-US/docs/Web/API/Document/write),
+        inheriting all its specific characteristics and behaviors.
+
+        Parameters
+        ----------
+        html : str
+            HTML markup to assign to the page.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_content(
+                html=html, timeout=to_milliseconds(timeout), waitUntil=wait_until
+            )
+        )
+
+    async def goto(
+        self,
+        url: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        referer: typing.Optional[str] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.goto
+
+        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` 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()`.
+
+        **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).
+
+        Parameters
+        ----------
+        url : str
+            URL to navigate page to. The url should include scheme, e.g. `https://`. When a `baseURL` 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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+        referer : Union[str, None]
+            Referer header value. If provided it will take preference over the referer header value set by
+            `page.set_extra_http_headers()`.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+
+        return mapping.from_impl_nullable(
+            await self._impl_obj.goto(
+                url=url,
+                timeout=to_milliseconds(timeout),
+                waitUntil=wait_until,
+                referer=referer,
+            )
+        )
+
+    async def reload(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.reload
+
+        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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+
+        return mapping.from_impl_nullable(
+            await self._impl_obj.reload(
+                timeout=to_milliseconds(timeout), waitUntil=wait_until
+            )
+        )
+
+    async def wait_for_load_state(
+        self,
+        state: typing.Optional[
+            Literal["domcontentloaded", "load", "networkidle"]
+        ] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Page.wait_for_load_state
+
+        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/python/docs/actionability).
+
+        **Usage**
+
+        ```py
+        await page.get_by_role(\"button\").click() # click triggers navigation.
+        await page.wait_for_load_state() # the promise resolves after \"load\" event.
+        ```
+
+        ```py
+        async with page.expect_popup() as page_info:
+            await page.get_by_role(\"button\").click() # click triggers a popup.
+        popup = await page_info.value
+        # Wait for the \"DOMContentLoaded\" event.
+        await popup.wait_for_load_state(\"domcontentloaded\")
+        print(await popup.title()) # popup is ready to use.
+        ```
+
+        Parameters
+        ----------
+        state : Union["domcontentloaded", "load", "networkidle", None]
+            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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for_load_state(
+                state=state, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def wait_for_url(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        *,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Page.wait_for_url
+
+        Waits for the main frame to navigate to the given URL.
+
+        **Usage**
+
+        ```py
+        await page.click(\"a.delayed-navigation\") # clicking the link will indirectly cause a navigation
+        await page.wait_for_url(\"**/target.html\")
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            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.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for_url(
+                url=self._wrap_handler(url),
+                waitUntil=wait_until,
+                timeout=to_milliseconds(timeout),
+            )
+        )
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "ConsoleMessage": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["crash"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Dialog": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["domcontentloaded"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Download": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["filechooser"],
+        predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "FileChooser": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["load"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["pageerror"],
+        predicate: typing.Optional[typing.Callable[["Error"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Error": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["popup"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Response": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["websocket"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebSocket": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["worker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Worker": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
+
+    async def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Any:
+        """Page.wait_for_event
+
+        **NOTE** In most cases, you should use `page.expect_event()`.
+
+        Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function
+        and waits for `predicate(event)` to return a truthy value. Will throw an error if the page is closed before the
+        `event` is fired.
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for_event(
+                event=event,
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            )
+        )
+
+    async def go_back(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.go_back
+
+        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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+
+        return mapping.from_impl_nullable(
+            await self._impl_obj.go_back(
+                timeout=to_milliseconds(timeout), waitUntil=wait_until
+            )
+        )
+
+    async def go_forward(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.go_forward
+
+        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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+
+        return mapping.from_impl_nullable(
+            await self._impl_obj.go_forward(
+                timeout=to_milliseconds(timeout), waitUntil=wait_until
+            )
+        )
+
+    async def request_gc(self) -> None:
+        """Page.request_gc
+
+        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).
+
+        ```py
+        # 1. In your page, save a WeakRef for the \"suspect\".
+        await page.evaluate(\"globalThis.suspectWeakRef = new WeakRef(suspect)\")
+        # 2. Request garbage collection.
+        await page.request_gc()
+        # 3. Check that weak ref does not deref to the original object.
+        assert await page.evaluate(\"!globalThis.suspectWeakRef.deref()\")
+        ```
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.request_gc())
+
+    async def emulate_media(
+        self,
+        *,
+        media: typing.Optional[Literal["null", "print", "screen"]] = None,
+        color_scheme: typing.Optional[
+            Literal["dark", "light", "no-preference", "null"]
+        ] = None,
+        reduced_motion: typing.Optional[
+            Literal["no-preference", "null", "reduce"]
+        ] = None,
+        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
+    ) -> None:
+        """Page.emulate_media
+
+        This method changes the `CSS media type` through the `media` argument, and/or the `'prefers-colors-scheme'` media
+        feature, using the `colorScheme` argument.
+
+        **Usage**
+
+        ```py
+        await page.evaluate(\"matchMedia('screen').matches\")
+        # → True
+        await page.evaluate(\"matchMedia('print').matches\")
+        # → False
+
+        await page.emulate_media(media=\"print\")
+        await page.evaluate(\"matchMedia('screen').matches\")
+        # → False
+        await page.evaluate(\"matchMedia('print').matches\")
+        # → True
+
+        await page.emulate_media()
+        await page.evaluate(\"matchMedia('screen').matches\")
+        # → True
+        await page.evaluate(\"matchMedia('print').matches\")
+        # → False
+        ```
+
+        ```py
+        await page.emulate_media(color_scheme=\"dark\")
+        await page.evaluate(\"matchMedia('(prefers-color-scheme: dark)').matches\")
+        # → True
+        await page.evaluate(\"matchMedia('(prefers-color-scheme: light)').matches\")
+        # → False
+        ```
+
+        Parameters
+        ----------
+        media : Union["null", "print", "screen", None]
+            Changes the CSS media type of the page. The only allowed values are `'Screen'`, `'Print'` and `'Null'`. Passing
+            `'Null'` disables CSS media emulation.
+        color_scheme : Union["dark", "light", "no-preference", "null", None]
+            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.
+        reduced_motion : Union["no-preference", "null", "reduce", None]
+            Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. Passing
+            `null` disables reduced motion emulation.
+        forced_colors : Union["active", "none", "null", None]
+        contrast : Union["more", "no-preference", "null", None]
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.emulate_media(
+                media=media,
+                colorScheme=color_scheme,
+                reducedMotion=reduced_motion,
+                forcedColors=forced_colors,
+                contrast=contrast,
+            )
+        )
+
+    async def set_viewport_size(self, viewport_size: ViewportSize) -> None:
+        """Page.set_viewport_size
+
+        In the case of multiple pages in a single browser, each page can have its own viewport size. However,
+        `browser.new_context()` allows to set viewport size (and more) for all pages in the context at once.
+
+        `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.set_viewport_size()` will also reset
+        `screen` size, use `browser.new_context()` with `screen` and `viewport` parameters if you need better
+        control of these properties.
+
+        **Usage**
+
+        ```py
+        page = await browser.new_page()
+        await page.set_viewport_size({\"width\": 640, \"height\": 480})
+        await page.goto(\"https://example.com\")
+        ```
+
+        Parameters
+        ----------
+        viewport_size : {width: int, height: int}
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_viewport_size(viewportSize=viewport_size)
+        )
+
+    async def bring_to_front(self) -> None:
+        """Page.bring_to_front
+
+        Brings page to front (activates tab).
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.bring_to_front())
+
+    async def hide_highlight(self) -> None:
+        """Page.hide_highlight
+
+        Hide all locator highlight overlays previously added by `locator.highlight()` on this page.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.hide_highlight())
+
+    async def add_init_script(
+        self,
+        script: typing.Optional[str] = None,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+    ) -> "AsyncContextManager":
+        """Page.add_init_script
+
+        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:
+
+        ```py
+        # in your playwright script, assuming the preload.js file is in same directory
+        await page.add_init_script(path=\"./preload.js\")
+        ```
+
+        **NOTE** The order of evaluation of multiple scripts installed via `browser_context.add_init_script()` and
+        `page.add_init_script()` is not defined.
+
+        Parameters
+        ----------
+        script : Union[str, None]
+            Script to be evaluated in all pages in the browser context. Optional.
+        path : Union[pathlib.Path, str, None]
+            Path to the JavaScript file. If `path` is a relative path, then it is resolved relative to the current working
+            directory. Optional.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.add_init_script(script=script, path=path)
+        )
+
+    async def route(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Union[
+            typing.Callable[["Route"], typing.Any],
+            typing.Callable[["Route", "Request"], typing.Any],
+        ],
+        *,
+        times: typing.Optional[int] = None,
+    ) -> "AsyncContextManager":
+        """Page.route
+
+        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()` 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` to `'block'`.
+
+        **NOTE** `page.route()` will not intercept the first request of a popup page. Use
+        `browser_context.route()` instead.
+
+        **Usage**
+
+        An example of a naive handler that aborts all image requests:
+
+        ```py
+        page = await browser.new_page()
+        await page.route(\"**/*.{png,jpg,jpeg}\", lambda route: route.abort())
+        await page.goto(\"https://example.com\")
+        await browser.close()
+        ```
+
+        or the same snippet using a regex pattern instead:
+
+        ```py
+        page = await browser.new_page()
+        await page.route(re.compile(r\"(\\.png$)|(\\.jpg$)\"), lambda 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:
+
+        ```py
+        async def handle_route(route: Route):
+          if (\"my-string\" in route.request.post_data):
+            await route.fulfill(body=\"mocked-data\")
+          else:
+            await route.continue_()
+        await page.route(\"/api/**\", handle_route)
+        ```
+
+        If a request matches multiple registered routes, the most recently registered route takes precedence.
+
+        Page routes take precedence over browser context routes (set up with `browser_context.route()`) when request
+        matches both handlers.
+
+        To remove a route with its handler you can use `page.unroute()`.
+
+        **NOTE** Enabling routing disables http cache.
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            A glob pattern, regex pattern, or predicate that receives a [URL] to match during routing. If `baseURL` is set in
+            the context options and the provided URL is a string that does not start with `*`, it is resolved using the
+            [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.
+        handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
+            handler function to route the request.
+        times : Union[int, None]
+            How often a route should be used. By default it will be used every time.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.route(
+                url=self._wrap_handler(url),
+                handler=self._wrap_handler(handler),
+                times=times,
+            )
+        )
+
+    async def unroute(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Optional[
+            typing.Union[
+                typing.Callable[["Route"], typing.Any],
+                typing.Callable[["Route", "Request"], typing.Any],
+            ]
+        ] = None,
+    ) -> None:
+        """Page.unroute
+
+        Removes a route created with `page.route()`. When `handler` is not specified, removes all routes for the
+        `url`.
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while routing.
+        handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
+            Optional handler function to route the request.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.unroute(
+                url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+            )
+        )
+
+    async def route_web_socket(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Callable[["WebSocketRoute"], typing.Any],
+    ) -> None:
+        """Page.route_web_socket
+
+        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` for more details and
+        examples.
+
+        ```py
+        def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+          if message == \"request\":
+            ws.send(\"response\")
+
+        def handler(ws: WebSocketRoute):
+          ws.on_message(lambda message: message_handler(ws, message))
+
+        await page.route_web_socket(\"/ws\", handler)
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            Only WebSockets with the url matching this pattern will be routed. A string pattern can be relative to the
+            `baseURL` context option.
+        handler : Callable[[WebSocketRoute], Any]
+            Handler function to route the WebSocket.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.route_web_socket(
+                url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+            )
+        )
+
+    async def unroute_all(
+        self,
+        *,
+        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None,
+    ) -> None:
+        """Page.unroute_all
+
+        Removes all routes created with `page.route()` and `page.route_from_har()`.
+
+        Parameters
+        ----------
+        behavior : Union["default", "ignoreErrors", "wait", None]
+            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
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.unroute_all(behavior=behavior)
+        )
+
+    async def route_from_har(
+        self,
+        har: typing.Union[pathlib.Path, str],
+        *,
+        url: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        not_found: typing.Optional[Literal["abort", "fallback"]] = None,
+        update: typing.Optional[bool] = None,
+        update_content: typing.Optional[Literal["attach", "embed"]] = None,
+        update_mode: typing.Optional[Literal["full", "minimal"]] = None,
+    ) -> None:
+        """Page.route_from_har
+
+        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/python/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` to `'block'`.
+
+        Parameters
+        ----------
+        har : Union[pathlib.Path, str]
+            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.
+        url : Union[Pattern[str], str, None]
+            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.
+        not_found : Union["abort", "fallback", None]
+            - 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.
+        update : Union[bool, None]
+            If specified, updates the given HAR with the actual network information instead of serving from file. The file is
+            written to disk when `browser_context.close()` is called.
+        update_content : Union["attach", "embed", None]
+            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.
+        update_mode : Union["full", "minimal", None]
+            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`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.route_from_har(
+                har=har,
+                url=url,
+                notFound=not_found,
+                update=update,
+                updateContent=update_content,
+                updateMode=update_mode,
+            )
+        )
+
+    async def screenshot(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        type: typing.Optional[Literal["jpeg", "png"]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+        omit_background: typing.Optional[bool] = None,
+        full_page: typing.Optional[bool] = None,
+        clip: typing.Optional[FloatRect] = None,
+        animations: typing.Optional[Literal["allow", "disabled"]] = None,
+        caret: typing.Optional[Literal["hide", "initial"]] = None,
+        scale: typing.Optional[Literal["css", "device"]] = None,
+        mask: typing.Optional[typing.Sequence["Locator"]] = None,
+        mask_color: typing.Optional[str] = None,
+        style: typing.Optional[str] = None,
+    ) -> bytes:
+        """Page.screenshot
+
+        Returns the buffer with the captured screenshot.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        type : Union["jpeg", "png", None]
+            Specify screenshot type, defaults to `png`.
+        path : Union[pathlib.Path, str, None]
+            The file path to save the image to. The screenshot type will be inferred from file extension. If `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.
+        quality : Union[int, None]
+            The quality of the image, between 0-100. Not applicable to `png` images.
+        omit_background : Union[bool, None]
+            Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.
+            Defaults to `false`.
+        full_page : Union[bool, None]
+            When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Defaults to
+            `false`.
+        clip : Union[{x: float, y: float, width: float, height: float}, None]
+            An object which specifies clipping of the resulting image.
+        animations : Union["allow", "disabled", None]
+            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.
+        caret : Union["hide", "initial", None]
+            When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be
+            changed.  Defaults to `"hide"`.
+        scale : Union["css", "device", None]
+            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"`.
+        mask : Union[Sequence[Locator], None]
+            Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
+        mask_color : Union[str, None]
+            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`.
+        style : Union[str, None]
+            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.
+
+        Returns
+        -------
+        bytes
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.screenshot(
+                timeout=to_milliseconds(timeout),
+                type=type,
+                path=path,
+                quality=quality,
+                omitBackground=omit_background,
+                fullPage=full_page,
+                clip=clip,
+                animations=animations,
+                caret=caret,
+                scale=scale,
+                mask=mapping.to_impl(mask),
+                maskColor=mask_color,
+                style=style,
+            )
+        )
+
+    async def title(self) -> str:
+        """Page.title
+
+        Returns the page's title.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.title())
+
+    async def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        depth: typing.Optional[int] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = None,
+        boxes: typing.Optional[bool] = None,
+    ) -> str:
+        """Page.aria_snapshot
+
+        Captures the aria snapshot of the page. Read more about [aria snapshots](https://playwright.dev/python/docs/aria-snapshots).
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
+        mode : Union["ai", "default", None]
+            When set to `"ai"`, returns a snapshot optimized for AI consumption: including element references like `[ref=e2]`
+            and snapshots of `<iframe>`s. Defaults to `"default"`.
+        boxes : Union[bool, None]
+            When `true`, appends each element's bounding box as `[box=x,y,width,height]` to the snapshot. Coordinates are
+            relative to the viewport, in CSS pixels, as returned by
+            [`Element.getBoundingClientRect()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
+            Defaults to `false`.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.aria_snapshot(
+                timeout=to_milliseconds(timeout), depth=depth, mode=mode, boxes=boxes
+            )
+        )
+
+    async def close(
+        self,
+        *,
+        run_before_unload: typing.Optional[bool] = None,
+        reason: typing.Optional[str] = None,
+    ) -> None:
+        """Page.close
+
+        If `runBeforeUnload` is `false`, does not run any unload handlers and waits for the page to be closed. If
+        `runBeforeUnload` 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` is passed as true, a `beforeunload` dialog might be summoned and should be handled
+        manually via `page.on('dialog')` event.
+
+        Parameters
+        ----------
+        run_before_unload : Union[bool, None]
+            Defaults to `false`. Whether to run the
+            [before unload](https://developer.mozilla.org/en-US/docs/Web/Events/beforeunload) page handlers.
+        reason : Union[str, None]
+            The reason to be reported to the operations interrupted by the page closure.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.close(runBeforeUnload=run_before_unload, reason=reason)
+        )
+
+    def is_closed(self) -> bool:
+        """Page.is_closed
+
+        Indicates that the page has been closed.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.is_closed())
+
+    async def click(
+        self,
+        selector: str,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.click
+
+        This method clicks an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to click in the center of the element, or the specified `position`.
+        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
+            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
+        button : Union["left", "middle", "right", None]
+            Defaults to `left`.
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        strict : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.click(
+                selector=selector,
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                delay=delay,
+                button=button,
+                clickCount=click_count,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+                strict=strict,
+            )
+        )
+
+    async def dblclick(
+        self,
+        selector: str,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.dblclick
+
+        This method double clicks an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to double click in the center of the element, or the specified `position`.
+
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **NOTE** `page.dblclick()` dispatches two `click` events and a single `dblclick` event.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
+            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
+        button : Union["left", "middle", "right", None]
+            Defaults to `left`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.dblclick(
+                selector=selector,
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                delay=delay,
+                button=button,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                trial=trial,
+            )
+        )
+
+    async def tap(
+        self,
+        selector: str,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.tap
+
+        This method taps an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to tap the center of the element, or the specified `position`.
+
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **NOTE** `page.tap()` the method will throw if `hasTouch` option of the browser context is false.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.tap(
+                selector=selector,
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                trial=trial,
+            )
+        )
+
+    async def fill(
+        self,
+        selector: str,
+        value: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.fill
+
+        This method waits for an element matching `selector`, waits for [actionability](https://playwright.dev/python/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.press_sequentially()`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        value : str
+            Value to fill for the `<input>`, `<textarea>` or `[contenteditable]` element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.fill(
+                selector=selector,
+                value=value,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                force=force,
+            )
+        )
+
+    def locator(
+        self,
+        selector: str,
+        *,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has: typing.Optional["Locator"] = None,
+        has_not: typing.Optional["Locator"] = None,
+    ) -> "Locator":
+        """Page.locator
+
+        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/python/docs/locators).
+
+        Parameters
+        ----------
+        selector : str
+            A selector to use when resolving DOM element.
+        has_text : Union[Pattern[str], str, None]
+            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>`.
+        has_not_text : Union[Pattern[str], str, None]
+            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.
+        has : Union[Locator, None]
+            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`s.
+        has_not : Union[Locator, None]
+            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`s.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.locator(
+                selector=selector,
+                hasText=has_text,
+                hasNotText=has_not_text,
+                has=has._impl_obj if has else None,
+                hasNot=has_not._impl_obj if has_not else None,
+            )
+        )
+
+    def get_by_alt_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Page.get_by_alt_text
+
+        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'>
+        ```
+
+        ```py
+        await page.get_by_alt_text(\"Playwright logo\").click()
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_alt_text(text=text, exact=exact))
+
+    def get_by_label(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Page.get_by_label
+
+        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\">
+        ```
+
+        ```py
+        await page.get_by_label(\"Username\").fill(\"john\")
+        await page.get_by_label(\"Password\").fill(\"secret\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_label(text=text, exact=exact))
+
+    def get_by_placeholder(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Page.get_by_placeholder
+
+        Allows locating input elements by the placeholder text.
+
+        **Usage**
+
+        For example, consider the following DOM structure.
+
+        ```html
+        <input type=\"email\" placeholder=\"name@example.com\" />
+        ```
+
+        You can fill the input after locating it by the placeholder text:
+
+        ```py
+        await page.get_by_placeholder(\"name@example.com\").fill(\"playwright@microsoft.com\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_placeholder(text=text, exact=exact)
+        )
+
+    def get_by_role(
+        self,
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
+        ],
+        *,
+        checked: typing.Optional[bool] = None,
+        disabled: typing.Optional[bool] = None,
+        expanded: typing.Optional[bool] = None,
+        include_hidden: typing.Optional[bool] = None,
+        level: typing.Optional[int] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        pressed: typing.Optional[bool] = None,
+        selected: typing.Optional[bool] = None,
+        exact: typing.Optional[bool] = None,
+        description: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> "Locator":
+        """Page.get_by_role
+
+        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 its implicit role:
+
+        ```py
+        await expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
+
+        await page.get_by_role(\"checkbox\", name=\"Subscribe\").check()
+
+        await page.get_by_role(\"button\", name=re.compile(\"submit\", re.IGNORECASE)).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.
+
+        Parameters
+        ----------
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        checked : Union[bool, None]
+            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).
+        disabled : Union[bool, None]
+            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).
+
+        expanded : Union[bool, None]
+            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).
+        include_hidden : Union[bool, None]
+            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).
+        level : Union[int, None]
+            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).
+        name : Union[Pattern[str], str, None]
+            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` to control this behavior.
+
+            Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
+        pressed : Union[bool, None]
+            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).
+        selected : Union[bool, None]
+            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).
+        exact : Union[bool, None]
+            Whether `name` and `description` are matched exactly: case-sensitive and whole-string. Defaults to false. Ignored
+            when the value is a regular expression. Note that exact match still trims whitespace.
+        description : Union[Pattern[str], str, None]
+            Option to match the [accessible description](https://w3c.github.io/accname/#dfn-accessible-description). By
+            default, matching is case-insensitive and searches for a substring, use `exact` to control this behavior.
+
+            Learn more about [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_role(
+                role=role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=include_hidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
+
+    def get_by_test_id(
+        self, test_id: typing.Union[str, typing.Pattern[str]]
+    ) -> "Locator":
+        """Page.get_by_test_id
+
+        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 its test id:
+
+        ```py
+        await page.get_by_test_id(\"directions\").click()
+        ```
+
+        **Details**
+
+        By default, the `data-testid` attribute is used as a test id. Use `selectors.set_test_id_attribute()` to
+        configure a different test id attribute if necessary.
+
+        Parameters
+        ----------
+        test_id : Union[Pattern[str], str]
+            Id to locate the element by.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_test_id(testId=test_id))
+
+    def get_by_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Page.get_by_text
+
+        Allows locating elements that contain given text.
+
+        See also `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:
+
+        ```py
+        # Matches <span>
+        page.get_by_text(\"world\")
+
+        # Matches first <div>
+        page.get_by_text(\"Hello world\")
+
+        # Matches second <div>
+        page.get_by_text(\"Hello\", exact=True)
+
+        # Matches both <div>s
+        page.get_by_text(re.compile(\"Hello\"))
+
+        # Matches second <div>
+        page.get_by_text(re.compile(\"^hello$\", re.IGNORECASE))
+        ```
+
+        **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\">`.
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_text(text=text, exact=exact))
+
+    def get_by_title(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Page.get_by_title
+
+        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:
+
+        ```py
+        await expect(page.get_by_title(\"Issues count\")).to_have_text(\"25 issues\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_title(text=text, exact=exact))
+
+    def frame_locator(self, selector: str) -> "FrameLocator":
+        """Page.frame_locator
+
+        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\">`:
+
+        ```py
+        locator = page.frame_locator(\"#my-iframe\").get_by_text(\"Submit\")
+        await locator.click()
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to use when resolving DOM element.
+
+        Returns
+        -------
+        FrameLocator
+        """
+
+        return mapping.from_impl(self._impl_obj.frame_locator(selector=selector))
+
+    async def focus(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Page.focus
+
+        This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the
+        method waits until a matching element appears in the DOM.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.focus(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def text_content(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Page.text_content
+
+        Returns `element.textContent`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.text_content(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def inner_text(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Page.inner_text
+
+        Returns `element.innerText`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.inner_text(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def inner_html(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Page.inner_html
+
+        Returns `element.innerHTML`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.inner_html(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def get_attribute(
+        self,
+        selector: str,
+        name: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Page.get_attribute
+
+        Returns element attribute value.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        name : str
+            Attribute name to get the value for.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.get_attribute(
+                selector=selector,
+                name=name,
+                strict=strict,
+                timeout=to_milliseconds(timeout),
+            )
+        )
+
+    async def hover(
+        self,
+        selector: str,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.hover
+
+        This method hovers over an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to hover over the center of the element, or the specified `position`.
+
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.hover(
+                selector=selector,
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                force=force,
+                strict=strict,
+                trial=trial,
+            )
+        )
+
+    async def drag_and_drop(
+        self,
+        source: str,
+        target: str,
+        *,
+        source_position: typing.Optional[Position] = None,
+        target_position: typing.Optional[Position] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
+        """Page.drag_and_drop
+
+        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**
+
+        ```py
+        await page.drag_and_drop(\"#source\", \"#target\")
+        # or specify exact positions relative to the top-left corners of the elements:
+        await page.drag_and_drop(
+          \"#source\",
+          \"#target\",
+          source_position={\"x\": 34, \"y\": 7},
+          target_position={\"x\": 10, \"y\": 20}
+        )
+        ```
+
+        Parameters
+        ----------
+        source : str
+            A selector to search for an element to drag. If there are multiple elements satisfying the selector, the first will
+            be used.
+        target : str
+            A selector to search for an element to drop onto. If there are multiple elements satisfying the selector, the first
+            will be used.
+        source_position : Union[{x: float, y: float}, None]
+            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.
+        target_position : Union[{x: float, y: float}, None]
+            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.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.drag_and_drop(
+                source=source,
+                target=target,
+                sourcePosition=source_position,
+                targetPosition=target_position,
+                force=force,
+                noWaitAfter=no_wait_after,
+                timeout=to_milliseconds(timeout),
+                strict=strict,
+                trial=trial,
+                steps=steps,
+            )
+        )
+
+    async def select_option(
+        self,
+        selector: str,
+        value: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        *,
+        index: typing.Optional[typing.Union[int, typing.Sequence[int]]] = None,
+        label: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        element: typing.Optional[
+            typing.Union["ElementHandle", typing.Sequence["ElementHandle"]]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> typing.List[str]:
+        """Page.select_option
+
+        This method waits for an element matching `selector`, waits for [actionability](https://playwright.dev/python/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**
+
+        ```py
+        # Single selection matching the value or label
+        await page.select_option(\"select#colors\", \"blue\")
+        # single selection matching the label
+        await page.select_option(\"select#colors\", label=\"blue\")
+        # multiple selection
+        await page.select_option(\"select#colors\", value=[\"red\", \"green\", \"blue\"])
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        value : Union[Sequence[str], str, None]
+            Options to select by value. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        index : Union[Sequence[int], int, None]
+            Options to select by index. Optional.
+        label : Union[Sequence[str], str, None]
+            Options to select by label. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        element : Union[ElementHandle, Sequence[ElementHandle], None]
+            Option elements to select. Optional.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        strict : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        List[str]
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.select_option(
+                selector=selector,
+                value=mapping.to_impl(value),
+                index=mapping.to_impl(index),
+                label=mapping.to_impl(label),
+                element=mapping.to_impl(element),
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                force=force,
+                strict=strict,
+            )
+        )
+
+    async def input_value(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Page.input_value
+
+        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.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.input_value(
+                selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def set_input_files(
+        self,
+        selector: str,
+        files: typing.Union[
+            str,
+            pathlib.Path,
+            FilePayload,
+            typing.Sequence[typing.Union[str, pathlib.Path]],
+            typing.Sequence[FilePayload],
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        strict: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.set_input_files
+
+        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` 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.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        files : Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}]
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        strict : Union[bool, None]
+            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.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_input_files(
+                selector=selector,
+                files=mapping.to_impl(files),
+                timeout=to_milliseconds(timeout),
+                strict=strict,
+                noWaitAfter=no_wait_after,
+            )
+        )
+
+    async def type(
+        self,
+        selector: str,
+        text: str,
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.type
+
+        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()`.
+
+        To press a special key, like `Control` or `ArrowDown`, use `keyboard.press()`.
+
+        **Usage**
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        text : str
+            A text to type into a focused element.
+        delay : Union[float, None]
+            Time to wait between key presses in milliseconds. Defaults to 0.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.type(
+                selector=selector,
+                text=text,
+                delay=delay,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                strict=strict,
+            )
+        )
+
+    async def press(
+        self,
+        selector: str,
+        key: str,
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.press
+
+        Focuses the element, and then uses `keyboard.down()` and `keyboard.up()`.
+
+        `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` 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` in the upper case.
+
+        If `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**
+
+        ```py
+        page = await browser.new_page()
+        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=\"arrow_left.png\")
+        await page.press(\"body\", \"Shift+O\")
+        await page.screenshot(path=\"o.png\")
+        await browser.close()
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        key : str
+            Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
+        delay : Union[float, None]
+            Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            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.
+        strict : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.press(
+                selector=selector,
+                key=key,
+                delay=delay,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                strict=strict,
+            )
+        )
+
+    async def check(
+        self,
+        selector: str,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.check
+
+        This method checks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.check(
+                selector=selector,
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                trial=trial,
+            )
+        )
+
+    async def uncheck(
+        self,
+        selector: str,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.uncheck
+
+        This method unchecks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.uncheck(
+                selector=selector,
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                trial=trial,
+            )
+        )
+
+    async def wait_for_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """Page.wait_for_timeout
+
+        Waits for the given `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**
+
+        ```py
+        # wait for 1 second
+        await page.wait_for_timeout(1000)
+        ```
+
+        Parameters
+        ----------
+        timeout : float
+            A timeout to wait for
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for_timeout(timeout=to_milliseconds(timeout))
+        )
+
+    async def wait_for_function(
+        self,
+        expression: str,
+        *,
+        arg: typing.Optional[typing.Any] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None,
+    ) -> "JSHandle":
+        """Page.wait_for_function
+
+        Returns when the `expression` returns a truthy value. It resolves to a JSHandle of the truthy value.
+
+        **Usage**
+
+        The `page.wait_for_function()` can be used to observe viewport size change:
+
+        ```py
+        import asyncio
+        from playwright.async_api import async_playwright, Playwright
+
+        async def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = await webkit.launch()
+            page = await browser.new_page()
+            await page.evaluate(\"window.x = 0; setTimeout(() => { window.x = 100 }, 1000);\")
+            await page.wait_for_function(\"() => window.x > 0\")
+            await browser.close()
+
+        async def main():
+            async with async_playwright() as playwright:
+                await run(playwright)
+        asyncio.run(main())
+        ```
+
+        To pass an argument to the predicate of `page.wait_for_function()` function:
+
+        ```py
+        selector = \".foo\"
+        await page.wait_for_function(\"selector => !!document.querySelector(selector)\", selector)
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()` or
+            `page.set_default_timeout()` methods.
+        polling : Union["raf", float, None]
+            If `polling` is `'raf'`, then `expression` is constantly executed in `requestAnimationFrame` callback. If `polling`
+            is a number, then it is treated as an interval in milliseconds at which the function would be executed. Defaults to
+            `raf`.
+
+        Returns
+        -------
+        JSHandle
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.wait_for_function(
+                expression=expression,
+                arg=mapping.to_impl(arg),
+                timeout=to_milliseconds(timeout),
+                polling=polling,
+            )
+        )
+
+    async def pause(self) -> None:
+        """Page.pause
+
+        Pauses script execution. Playwright will stop executing the script and wait for the user to either press the
+        '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` option.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.pause())
+
+    async def pdf(
+        self,
+        *,
+        scale: typing.Optional[float] = None,
+        display_header_footer: typing.Optional[bool] = None,
+        header_template: typing.Optional[str] = None,
+        footer_template: typing.Optional[str] = None,
+        print_background: typing.Optional[bool] = None,
+        landscape: typing.Optional[bool] = None,
+        page_ranges: typing.Optional[str] = None,
+        format: typing.Optional[str] = None,
+        width: typing.Optional[typing.Union[str, float]] = None,
+        height: typing.Optional[typing.Union[str, float]] = None,
+        prefer_css_page_size: typing.Optional[bool] = None,
+        margin: typing.Optional[PdfMargins] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        outline: typing.Optional[bool] = None,
+        tagged: typing.Optional[bool] = None,
+    ) -> bytes:
+        """Page.pdf
+
+        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.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**
+
+        ```py
+        # generates a pdf with \"screen\" media type.
+        await page.emulate_media(media=\"screen\")
+        await page.pdf(path=\"page.pdf\")
+        ```
+
+        The `width`, `height`, and `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` 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` and `footerTemplate` markup have the following limitations: > 1. Script tags inside
+        templates are not evaluated. > 2. Page styles are not visible inside templates.
+
+        Parameters
+        ----------
+        scale : Union[float, None]
+            Scale of the webpage rendering. Defaults to `1`. Scale amount must be between 0.1 and 2.
+        display_header_footer : Union[bool, None]
+            Display header and footer. Defaults to `false`.
+        header_template : Union[str, None]
+            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
+        footer_template : Union[str, None]
+            HTML template for the print footer. Should use the same format as the `headerTemplate`.
+        print_background : Union[bool, None]
+            Print background graphics. Defaults to `false`.
+        landscape : Union[bool, None]
+            Paper orientation. Defaults to `false`.
+        page_ranges : Union[str, None]
+            Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty string, which means print all pages.
+        format : Union[str, None]
+            Paper format. If set, takes priority over `width` or `height` options. Defaults to 'Letter'.
+        width : Union[float, str, None]
+            Paper width, accepts values labeled with units.
+        height : Union[float, str, None]
+            Paper height, accepts values labeled with units.
+        prefer_css_page_size : Union[bool, None]
+            Give any CSS `@page` size declared in the page priority over what is declared in `width` and `height` or `format`
+            options. Defaults to `false`, which will scale the content to fit the paper size.
+        margin : Union[{top: Union[float, str, None], right: Union[float, str, None], bottom: Union[float, str, None], left: Union[float, str, None]}, None]
+            Paper margins, defaults to none.
+        path : Union[pathlib.Path, str, None]
+            The file path to save the PDF to. If `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.
+        outline : Union[bool, None]
+            Whether or not to embed the document outline into the PDF. Defaults to `false`.
+        tagged : Union[bool, None]
+            Whether or not to generate tagged (accessible) PDF. Defaults to `false`.
+
+        Returns
+        -------
+        bytes
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.pdf(
+                scale=scale,
+                displayHeaderFooter=display_header_footer,
+                headerTemplate=header_template,
+                footerTemplate=footer_template,
+                printBackground=print_background,
+                landscape=landscape,
+                pageRanges=page_ranges,
+                format=format,
+                width=width,
+                height=height,
+                preferCSSPageSize=prefer_css_page_size,
+                margin=margin,
+                path=path,
+                outline=outline,
+                tagged=tagged,
+            )
+        )
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["ConsoleMessage"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["crash"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Dialog"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["domcontentloaded"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Download"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["filechooser"],
+        predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["FileChooser"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["load"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["pageerror"],
+        predicate: typing.Optional[typing.Callable[["Error"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Error"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["popup"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Response"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["websocket"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["WebSocket"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["worker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager[typing.Any]: ...
+
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager:
+        """Page.expect_event
+
+        Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+        value. Will throw an error if the page is closed before the event is fired. Returns the event data value.
+
+        **Usage**
+
+        ```py
+        async with page.expect_event(\"framenavigated\") as event_info:
+            await page.get_by_role(\"button\")
+        frame = await event_info.value
+        ```
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_event(
+                event=event,
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def expect_console_message(
+        self,
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["ConsoleMessage"]:
+        """Page.expect_console_message
+
+        Performs action and waits for a `ConsoleMessage` to be logged by in the page. If predicate is provided, it passes
+        `ConsoleMessage` value into the `predicate` function and waits for `predicate(message)` to return a truthy value.
+        Will throw an error if the page is closed before the `page.on('console')` event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[ConsoleMessage], bool], None]
+            Receives the `ConsoleMessage` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[ConsoleMessage]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_console_message(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def expect_download(
+        self,
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["Download"]:
+        """Page.expect_download
+
+        Performs action and waits for a new `Download`. If predicate is provided, it passes `Download` value into the
+        `predicate` function and waits for `predicate(download)` to return a truthy value. Will throw an error if the page
+        is closed before the download event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[Download], bool], None]
+            Receives the `Download` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[Download]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_download(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def expect_file_chooser(
+        self,
+        predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["FileChooser"]:
+        """Page.expect_file_chooser
+
+        Performs action and waits for a new `FileChooser` to be created. If predicate is provided, it passes `FileChooser`
+        value into the `predicate` function and waits for `predicate(fileChooser)` to return a truthy value. Will throw an
+        error if the page is closed before the file chooser is opened.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[FileChooser], bool], None]
+            Receives the `FileChooser` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[FileChooser]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_file_chooser(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def expect_navigation(
+        self,
+        *,
+        url: typing.Optional[
+            typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]]
+        ] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["Response"]:
+        """Page.expect_navigation
+
+        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:
+
+        ```py
+        async with page.expect_navigation():
+            # This action triggers the navigation after a timeout.
+            await page.get_by_text(\"Navigate after timeout\").click()
+        # Resolves after navigation has finished
+        ```
+
+        **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.
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str, None]
+            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.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        EventContextManager[Response]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_navigation(
+                url=self._wrap_handler(url),
+                waitUntil=wait_until,
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def expect_popup(
+        self,
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["Page"]:
+        """Page.expect_popup
+
+        Performs action and waits for a popup `Page`. If predicate is provided, it passes [Popup] value into the
+        `predicate` function and waits for `predicate(page)` to return a truthy value. Will throw an error if the page is
+        closed before the popup event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[Page], bool], None]
+            Receives the `Page` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[Page]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_popup(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def expect_request(
+        self,
+        url_or_predicate: typing.Union[
+            str,
+            typing.Pattern[str],
+            typing.Callable[["Request"], typing.Union[bool, typing.Awaitable[bool]]],
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["Request"]:
+        """Page.expect_request
+
+        Waits for the matching request and returns it. See [waiting for event](https://playwright.dev/python/docs/events#waiting-for-event) for more
+        details about events.
+
+        **Usage**
+
+        ```py
+        async with page.expect_request(\"http://example.com/resource\") as first:
+            await page.get_by_text(\"trigger request\").click()
+        first_request = await first.value
+
+        # or with a lambda
+        async with page.expect_request(lambda request: request.url == \"http://example.com\" and request.method == \"get\") as second:
+            await page.get_by_text(\"trigger request\").click()
+        second_request = await second.value
+        ```
+
+        Parameters
+        ----------
+        url_or_predicate : Union[Callable[[Request], Union[bool, typing.Awaitable[bool]]], Pattern[str], str]
+            Request URL string, regex or predicate receiving `Request` object. When a `baseURL` 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.
+        timeout : Union[float, None]
+            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.set_default_timeout()` method.
+
+        Returns
+        -------
+        EventContextManager[Request]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_request(
+                urlOrPredicate=self._wrap_handler(url_or_predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def expect_request_finished(
+        self,
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["Request"]:
+        """Page.expect_request_finished
+
+        Performs action and waits for a `Request` to finish loading. If predicate is provided, it passes `Request` value
+        into the `predicate` function and waits for `predicate(request)` to return a truthy value. Will throw an error if
+        the page is closed before the `page.on('request_finished')` event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[Request], bool], None]
+            Receives the `Request` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[Request]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_request_finished(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def expect_response(
+        self,
+        url_or_predicate: typing.Union[
+            str,
+            typing.Pattern[str],
+            typing.Callable[["Response"], typing.Union[bool, typing.Awaitable[bool]]],
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["Response"]:
+        """Page.expect_response
+
+        Returns the matched response. See [waiting for event](https://playwright.dev/python/docs/events#waiting-for-event) for more details about
+        events.
+
+        **Usage**
+
+        ```py
+        async with page.expect_response(\"https://example.com/resource\") as response_info:
+            await page.get_by_text(\"trigger response\").click()
+        response = await response_info.value
+        return response.ok
+
+        # or with a lambda
+        async with page.expect_response(lambda response: response.url == \"https://example.com\" and response.status == 200 and response.request.method == \"get\") as response_info:
+            await page.get_by_text(\"trigger response\").click()
+        response = await response_info.value
+        return response.ok
+        ```
+
+        Parameters
+        ----------
+        url_or_predicate : Union[Callable[[Response], Union[bool, typing.Awaitable[bool]]], Pattern[str], str]
+            Request URL string, regex or predicate receiving `Response` object. When a `baseURL` 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.
+        timeout : Union[float, None]
+            Maximum wait time in milliseconds, defaults to 30 seconds, pass `0` to disable the timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        EventContextManager[Response]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_response(
+                urlOrPredicate=self._wrap_handler(url_or_predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def expect_websocket(
+        self,
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["WebSocket"]:
+        """Page.expect_websocket
+
+        Performs action and waits for a new `WebSocket`. If predicate is provided, it passes `WebSocket` value into the
+        `predicate` function and waits for `predicate(webSocket)` to return a truthy value. Will throw an error if the page
+        is closed before the WebSocket event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[WebSocket], bool], None]
+            Receives the `WebSocket` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[WebSocket]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_websocket(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def expect_worker(
+        self,
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["Worker"]:
+        """Page.expect_worker
+
+        Performs action and waits for a new `Worker`. If predicate is provided, it passes `Worker` value into the
+        `predicate` function and waits for `predicate(worker)` to return a truthy value. Will throw an error if the page is
+        closed before the worker event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[Worker], bool], None]
+            Receives the `Worker` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[Worker]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_worker(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    async def set_checked(
+        self,
+        selector: str,
+        checked: bool,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.set_checked
+
+        This method checks or unchecks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        checked : bool
+            Whether to check or uncheck the checkbox.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_checked(
+                selector=selector,
+                checked=checked,
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                strict=strict,
+                trial=trial,
+            )
+        )
+
+    async def add_locator_handler(
+        self,
+        locator: "Locator",
+        handler: typing.Union[
+            typing.Callable[["Locator"], typing.Any], typing.Callable[[], typing.Any]
+        ],
+        *,
+        no_wait_after: typing.Optional[bool] = None,
+        times: typing.Optional[int] = None,
+    ) -> None:
+        """Page.add_locator_handler
+
+        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.add_locator_handler()`.
+        - Playwright checks for the overlay every time before executing or retrying an action that requires an
+          [actionability check](https://playwright.dev/python/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`.
+        - 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()` followed by `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()` instead to avoid this problem.
+
+        Another example is a series of mouse actions, where `mouse.move()` is followed by `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()` 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:
+
+        ```py
+        # Setup the handler.
+        def handler():
+          page.get_by_role(\"button\", name=\"No thanks\").click()
+        page.add_locator_handler(page.get_by_text(\"Sign up to the newsletter\"), handler)
+
+        # Write the test as usual.
+        page.goto(\"https://example.com\")
+        page.get_by_role(\"button\", name=\"Start here\").click()
+        ```
+
+        An example that skips the \"Confirm your security details\" page when it is shown:
+
+        ```py
+        # Setup the handler.
+        def handler():
+          page.get_by_role(\"button\", name=\"Remind me later\").click()
+        page.add_locator_handler(page.get_by_text(\"Confirm your security details\"), handler)
+
+        # Write the test as usual.
+        page.goto(\"https://example.com\")
+        page.get_by_role(\"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`, because the
+        handler does not hide the `<body>` element.
+
+        ```py
+        # Setup the handler.
+        def handler():
+          page.evaluate(\"window.removeObstructionsForTestIfNeeded()\")
+        page.add_locator_handler(page.locator(\"body\"), handler, no_wait_after=True)
+
+        # Write the test as usual.
+        page.goto(\"https://example.com\")
+        page.get_by_role(\"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`:
+
+        ```py
+        def handler(locator):
+          locator.click()
+        page.add_locator_handler(page.get_by_label(\"Close\"), handler, times=1)
+        ```
+
+        Parameters
+        ----------
+        locator : Locator
+            Locator that triggers the handler.
+        handler : Union[Callable[[Locator], Any], Callable[[], Any]]
+            Function that should be run once `locator` appears. This function should get rid of the element that blocks actions
+            like click.
+        no_wait_after : Union[bool, None]
+            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.
+        times : Union[int, None]
+            Specifies the maximum number of times this handler should be called. Unlimited by default.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.add_locator_handler(
+                locator=locator._impl_obj,
+                handler=self._wrap_handler(handler),
+                noWaitAfter=no_wait_after,
+                times=times,
+            )
+        )
+
+    async def remove_locator_handler(self, locator: "Locator") -> None:
+        """Page.remove_locator_handler
+
+        Removes all locator handlers added by `page.add_locator_handler()` for a specific locator.
+
+        Parameters
+        ----------
+        locator : Locator
+            Locator passed to `page.add_locator_handler()`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.remove_locator_handler(locator=locator._impl_obj)
+        )
+
+    async def requests(self) -> typing.List["Request"]:
+        """Page.requests
+
+        Returns up to (currently) 100 last network request from this page. See `page.on('request')` for more details.
+
+        Returned requests should be accessed immediately, otherwise they might be collected to prevent unbounded memory
+        growth as new requests come in. Once collected, retrieving most information about the request is impossible.
+
+        Note that requests reported through the `page.on('request')` request are not collected, so there is a trade off
+        between efficient memory usage with `page.requests()` and the amount of available information reported
+        through `page.on('request')`.
+
+        Returns
+        -------
+        List[Request]
+        """
+
+        return mapping.from_impl_list(await self._impl_obj.requests())
+
+    async def console_messages(
+        self, *, filter: typing.Optional[Literal["all", "since-navigation"]] = None
+    ) -> typing.List["ConsoleMessage"]:
+        """Page.console_messages
+
+        Returns up to (currently) 200 last console messages from this page. See `page.on('console')` for more details.
+
+        Parameters
+        ----------
+        filter : Union["all", "since-navigation", None]
+            Controls which messages are returned:
+
+        Returns
+        -------
+        List[ConsoleMessage]
+        """
+
+        return mapping.from_impl_list(
+            await self._impl_obj.console_messages(filter=filter)
+        )
+
+    async def page_errors(
+        self, *, filter: typing.Optional[Literal["all", "since-navigation"]] = None
+    ) -> typing.List["Error"]:
+        """Page.page_errors
+
+        Returns up to (currently) 200 last page errors from this page. See `page.on('page_error')` for more details.
+
+        Parameters
+        ----------
+        filter : Union["all", "since-navigation", None]
+            Controls which errors are returned:
+
+        Returns
+        -------
+        List[Error]
+        """
+
+        return mapping.from_impl_list(await self._impl_obj.page_errors(filter=filter))
+
+    async def clear_console_messages(self) -> None:
+        """Page.clear_console_messages
+
+        Clears all stored console messages from this page. Subsequent calls to `page.console_messages()` will only
+        return messages logged after the clear.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.clear_console_messages())
+
+    async def clear_page_errors(self) -> None:
+        """Page.clear_page_errors
+
+        Clears all stored page errors from this page. Subsequent calls to `page.page_errors()` will only return
+        errors thrown after the clear.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.clear_page_errors())
+
+    async def pick_locator(self) -> "Locator":
+        """Page.pick_locator
+
+        Enters pick locator mode where hovering over page elements highlights them and shows the corresponding locator.
+        Once the user clicks an element, the mode is deactivated and the `Locator` for the picked element is returned.
+
+        **Usage**
+
+        ```py
+        locator = await page.pick_locator()
+        print(locator)
+        ```
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(await self._impl_obj.pick_locator())
+
+    async def cancel_pick_locator(self) -> None:
+        """Page.cancel_pick_locator
+
+        Cancels an ongoing `page.pick_locator()` call by deactivating pick locator mode. If no pick locator mode is
+        active, this method is a no-op.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.cancel_pick_locator())
+
+
+mapping.register(PageImpl, Page)
+
+
+class WebError(AsyncBase):
+
+    @property
+    def page(self) -> typing.Optional["Page"]:
+        """WebError.page
+
+        The page that produced this unhandled exception, if any.
+
+        Returns
+        -------
+        Union[Page, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.page)
+
+    @property
+    def error(self) -> "Error":
+        """WebError.error
+
+        Unhandled error that was thrown.
+
+        Returns
+        -------
+        Error
+        """
+        return mapping.from_impl(self._impl_obj.error)
+
+    @property
+    def location(self) -> WebErrorLocation:
+        """WebError.location
+
+        Returns
+        -------
+        {url: str, line: int, column: int}
+        """
+        return mapping.from_impl(self._impl_obj.location)
+
+
+mapping.register(WebErrorImpl, WebError)
+
+
+class BrowserContext(AsyncContextManager):
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["backgroundpage"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        This event is not emitted."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[
+            ["BrowserContext"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        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()` method was called."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["console"],
+        f: typing.Callable[
+            ["ConsoleMessage"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        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` event handler argument.
+
+        **Usage**
+
+        ```py
+        async def print_args(msg):
+            values = []
+            for arg in msg.args:
+                values.append(await arg.json_value())
+            print(values)
+
+        context.on(\"console\", print_args)
+        await page.evaluate(\"console.log('hello', 5, { foo: 'bar' })\")
+        ```"""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["dialog"],
+        f: typing.Callable[["Dialog"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**
+        either `dialog.accept()` or `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**
+
+        ```python
+        context.on(\"dialog\", lambda dialog: dialog.accept())
+        ```
+
+        **NOTE** When no `page.on('dialog')` or `browser_context.on('dialog')` listeners are present, all dialogs are
+        automatically dismissed."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["download"],
+        f: typing.Callable[["Download"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when attachment download started in any page belonging to this context. User can access basic file
+        operations on downloaded content via the passed `Download` instance. See also `page.on('download')` to receive
+        events about a specific page."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["frameattached"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is attached in any page belonging to this context. See also `page.on('frame_attached')` to
+        receive events about a specific page."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["framedetached"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is detached in any page belonging to this context. See also `page.on('frame_detached')` to
+        receive events about a specific page."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["framenavigated"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is navigated to a new url in any page belonging to this context. See also
+        `page.on('frame_navigated')` to receive events about navigations in a specific page.
+        """
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["page"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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')` 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 `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
+
+        ```py
+        async with context.expect_page() as page_info:
+            await page.get_by_text(\"open new page\").click(),
+        page = await page_info.value
+        print(await page.evaluate(\"location.href\"))
+        ```
+
+        **NOTE** Use `page.wait_for_load_state()` to wait until the page gets to a particular state (you should not
+        need it in most cases)."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["pageclose"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a page in this context is closed. See also `page.on('close')` to receive events about a specific
+        page."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["pageload"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched
+        in any page belonging to this context. See also `page.on('load')` to receive events about a specific page.
+        """
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["weberror"],
+        f: typing.Callable[["WebError"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when exception is unhandled in any of the pages in this context. To listen for errors from a particular
+        page, use `page.on('page_error')` instead."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["request"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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')`.
+
+        In order to intercept and mutate requests, see `browser_context.route()` or `page.route()`.
+        """
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["requestfailed"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a request fails, for example by timing out. To only listen for failed requests from a particular page,
+        use `page.on('request_failed')`.
+
+        **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request
+        will complete with `browser_context.on('request_finished')` event and not with
+        `browser_context.on('request_failed')`."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["requestfinished"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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('request_finished')`."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["response"],
+        f: typing.Callable[["Response"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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')`."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["serviceworker"],
+        f: typing.Callable[["Worker"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        **NOTE** Service workers are only supported on Chromium-based browsers.
+
+        Emitted when new service worker is created in the context."""
+
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["backgroundpage"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        This event is not emitted."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[
+            ["BrowserContext"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        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()` method was called."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["console"],
+        f: typing.Callable[
+            ["ConsoleMessage"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        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` event handler argument.
+
+        **Usage**
+
+        ```py
+        async def print_args(msg):
+            values = []
+            for arg in msg.args:
+                values.append(await arg.json_value())
+            print(values)
+
+        context.on(\"console\", print_args)
+        await page.evaluate(\"console.log('hello', 5, { foo: 'bar' })\")
+        ```"""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["dialog"],
+        f: typing.Callable[["Dialog"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**
+        either `dialog.accept()` or `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**
+
+        ```python
+        context.on(\"dialog\", lambda dialog: dialog.accept())
+        ```
+
+        **NOTE** When no `page.on('dialog')` or `browser_context.on('dialog')` listeners are present, all dialogs are
+        automatically dismissed."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["download"],
+        f: typing.Callable[["Download"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when attachment download started in any page belonging to this context. User can access basic file
+        operations on downloaded content via the passed `Download` instance. See also `page.on('download')` to receive
+        events about a specific page."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["frameattached"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is attached in any page belonging to this context. See also `page.on('frame_attached')` to
+        receive events about a specific page."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["framedetached"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is detached in any page belonging to this context. See also `page.on('frame_detached')` to
+        receive events about a specific page."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["framenavigated"],
+        f: typing.Callable[["Frame"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a frame is navigated to a new url in any page belonging to this context. See also
+        `page.on('frame_navigated')` to receive events about navigations in a specific page.
+        """
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["page"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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')` 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 `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
+
+        ```py
+        async with context.expect_page() as page_info:
+            await page.get_by_text(\"open new page\").click(),
+        page = await page_info.value
+        print(await page.evaluate(\"location.href\"))
+        ```
+
+        **NOTE** Use `page.wait_for_load_state()` to wait until the page gets to a particular state (you should not
+        need it in most cases)."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["pageclose"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a page in this context is closed. See also `page.on('close')` to receive events about a specific
+        page."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["pageload"],
+        f: typing.Callable[["Page"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched
+        in any page belonging to this context. See also `page.on('load')` to receive events about a specific page.
+        """
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["weberror"],
+        f: typing.Callable[["WebError"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when exception is unhandled in any of the pages in this context. To listen for errors from a particular
+        page, use `page.on('page_error')` instead."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["request"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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')`.
+
+        In order to intercept and mutate requests, see `browser_context.route()` or `page.route()`.
+        """
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["requestfailed"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        Emitted when a request fails, for example by timing out. To only listen for failed requests from a particular page,
+        use `page.on('request_failed')`.
+
+        **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request
+        will complete with `browser_context.on('request_finished')` event and not with
+        `browser_context.on('request_failed')`."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["requestfinished"],
+        f: typing.Callable[["Request"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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('request_finished')`."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["response"],
+        f: typing.Callable[["Response"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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')`."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["serviceworker"],
+        f: typing.Callable[["Worker"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        **NOTE** Service workers are only supported on Chromium-based browsers.
+
+        Emitted when new service worker is created in the context."""
+
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def pages(self) -> typing.List["Page"]:
+        """BrowserContext.pages
+
+        Returns all open pages in the context.
+
+        Returns
+        -------
+        List[Page]
+        """
+        return mapping.from_impl_list(self._impl_obj.pages)
+
+    @property
+    def browser(self) -> typing.Optional["Browser"]:
+        """BrowserContext.browser
+
+        Gets the browser instance that owns the context. Returns `null` if the context is created outside of normal
+        browser, e.g. Android or Electron.
+
+        Returns
+        -------
+        Union[Browser, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.browser)
+
+    @property
+    def background_pages(self) -> typing.List["Page"]:
+        """BrowserContext.background_pages
+
+        Returns an empty list.
+
+        Returns
+        -------
+        List[Page]
+        """
+        return mapping.from_impl_list(self._impl_obj.background_pages)
+
+    @property
+    def service_workers(self) -> typing.List["Worker"]:
+        """BrowserContext.service_workers
+
+        **NOTE** Service workers are only supported on Chromium-based browsers.
+
+        All existing service workers in the context.
+
+        Returns
+        -------
+        List[Worker]
+        """
+        return mapping.from_impl_list(self._impl_obj.service_workers)
+
+    @property
+    def tracing(self) -> "Tracing":
+        """BrowserContext.tracing
+
+        Returns
+        -------
+        Tracing
+        """
+        return mapping.from_impl(self._impl_obj.tracing)
+
+    @property
+    def debugger(self) -> "Debugger":
+        """BrowserContext.debugger
+
+        Debugger allows to pause and resume the execution.
+
+        Returns
+        -------
+        Debugger
+        """
+        return mapping.from_impl(self._impl_obj.debugger)
+
+    @property
+    def request(self) -> "APIRequestContext":
+        """BrowserContext.request
+
+        API testing helper associated with this context. Requests made with this API will use context cookies.
+
+        Returns
+        -------
+        APIRequestContext
+        """
+        return mapping.from_impl(self._impl_obj.request)
+
+    @property
+    def clock(self) -> "Clock":
+        """BrowserContext.clock
+
+        Playwright has ability to mock clock and passage of time.
+
+        Returns
+        -------
+        Clock
+        """
+        return mapping.from_impl(self._impl_obj.clock)
+
+    def set_default_navigation_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """BrowserContext.set_default_navigation_timeout
+
+        This setting will change the default maximum navigation time for the following methods and related shortcuts:
+        - `page.go_back()`
+        - `page.go_forward()`
+        - `page.goto()`
+        - `page.reload()`
+        - `page.set_content()`
+        - `page.expect_navigation()`
+
+        **NOTE** `page.set_default_navigation_timeout()` and `page.set_default_timeout()` take priority over
+        `browser_context.set_default_navigation_timeout()`.
+
+        Parameters
+        ----------
+        timeout : float
+            Maximum navigation time in milliseconds
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_default_navigation_timeout(
+                timeout=to_milliseconds(timeout)
+            )
+        )
+
+    def set_default_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """BrowserContext.set_default_timeout
 
         This setting will change the default maximum time for all the methods accepting `timeout` option.
 
-        **NOTE** page.set_default_navigation_timeout(timeout) takes priority over page.set_default_timeout(timeout).
+        **NOTE** `page.set_default_navigation_timeout()`, `page.set_default_timeout()` and
+        `browser_context.set_default_navigation_timeout()` take priority over
+        `browser_context.set_default_timeout()`.
+
+        Parameters
+        ----------
+        timeout : float
+            Maximum time in milliseconds. Pass `0` to disable timeout.
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_default_timeout(timeout=to_milliseconds(timeout))
+        )
+
+    async def new_page(self) -> "Page":
+        """BrowserContext.new_page
+
+        Creates a new page in the browser context.
+
+        Returns
+        -------
+        Page
+        """
+
+        return mapping.from_impl(await self._impl_obj.new_page())
+
+    async def cookies(
+        self, urls: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None
+    ) -> typing.List[Cookie]:
+        """BrowserContext.cookies
+
+        If no URLs are specified, this method returns all cookies. If URLs are specified, only cookies that affect those
+        URLs are returned.
+
+        Parameters
+        ----------
+        urls : Union[Sequence[str], str, None]
+            Optional list of URLs.
+
+        Returns
+        -------
+        List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"], partitionKey: Union[str, None]}]
+        """
+
+        return mapping.from_impl_list(
+            await self._impl_obj.cookies(urls=mapping.to_impl(urls))
+        )
+
+    async def add_cookies(self, cookies: typing.Sequence[SetCookieParam]) -> None:
+        """BrowserContext.add_cookies
+
+        Adds cookies into this browser context. All pages within this context will have these cookies installed. Cookies
+        can be obtained via `browser_context.cookies()`.
+
+        **Usage**
+
+        ```py
+        await browser_context.add_cookies([cookie_object1, cookie_object2])
+        ```
+
+        Parameters
+        ----------
+        cookies : Sequence[{name: str, value: str, url: Union[str, None], domain: Union[str, None], path: Union[str, None], expires: Union[float, None], httpOnly: Union[bool, None], secure: Union[bool, None], sameSite: Union["Lax", "None", "Strict", None], partitionKey: Union[str, None]}]
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.add_cookies(cookies=mapping.to_impl(cookies))
+        )
+
+    async def clear_cookies(
+        self,
+        *,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        domain: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        path: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> None:
+        """BrowserContext.clear_cookies
+
+        Removes cookies from context. Accepts optional filter.
+
+        **Usage**
+
+        ```py
+        await context.clear_cookies()
+        await context.clear_cookies(name=\"session-id\")
+        await context.clear_cookies(domain=\"my-origin.com\")
+        await context.clear_cookies(path=\"/api/v1\")
+        await context.clear_cookies(name=\"session-id\", domain=\"my-origin.com\")
+        ```
+
+        Parameters
+        ----------
+        name : Union[Pattern[str], str, None]
+            Only removes cookies with the given name.
+        domain : Union[Pattern[str], str, None]
+            Only removes cookies with the given domain.
+        path : Union[Pattern[str], str, None]
+            Only removes cookies with the given path.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.clear_cookies(name=name, domain=domain, path=path)
+        )
+
+    async def grant_permissions(
+        self, permissions: typing.Sequence[str], *, origin: typing.Optional[str] = None
+    ) -> None:
+        """BrowserContext.grant_permissions
+
+        Grants specified permissions to the browser context. Only grants corresponding permissions to the given origin if
+        specified.
+
+        Parameters
+        ----------
+        permissions : Sequence[str]
+            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'`
+            - `'local-fonts'`
+            - `'local-network-access'`
+            - `'magnetometer'`
+            - `'microphone'`
+            - `'midi-sysex'` (system-exclusive midi)
+            - `'midi'`
+            - `'notifications'`
+            - `'payment-handler'`
+            - `'storage-access'`
+            - `'screen-wake-lock'`
+        origin : Union[str, None]
+            The [origin] to grant permissions to, e.g. "https://example.com".
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.grant_permissions(
+                permissions=mapping.to_impl(permissions), origin=origin
+            )
+        )
+
+    async def clear_permissions(self) -> None:
+        """BrowserContext.clear_permissions
+
+        Clears all permission overrides for the browser context.
+
+        **Usage**
+
+        ```py
+        context = await browser.new_context()
+        await context.grant_permissions([\"clipboard-read\"])
+        # do stuff ..
+        context.clear_permissions()
+        ```
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.clear_permissions())
+
+    async def set_geolocation(
+        self, geolocation: typing.Optional[Geolocation] = None
+    ) -> None:
+        """BrowserContext.set_geolocation
+
+        Sets the context's geolocation. Passing `null` or `undefined` emulates position unavailable.
+
+        **Usage**
+
+        ```py
+        await browser_context.set_geolocation({\"latitude\": 59.95, \"longitude\": 30.31667})
+        ```
+
+        **NOTE** Consider using `browser_context.grant_permissions()` to grant permissions for the browser context
+        pages to read its geolocation.
+
+        Parameters
+        ----------
+        geolocation : Union[{latitude: float, longitude: float, accuracy: Union[float, None]}, None]
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_geolocation(geolocation=geolocation)
+        )
+
+    async def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> None:
+        """BrowserContext.set_extra_http_headers
+
+        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.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** `browser_context.set_extra_http_headers()` does not guarantee the order of headers in the outgoing
+        requests.
+
+        Parameters
+        ----------
+        headers : Dict[str, str]
+            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_extra_http_headers(
+                headers=mapping.to_impl(headers)
+            )
+        )
+
+    async def set_offline(self, offline: bool) -> None:
+        """BrowserContext.set_offline
+
+        Parameters
+        ----------
+        offline : bool
+            Whether to emulate network being offline for the browser context.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_offline(offline=offline)
+        )
+
+    async def add_init_script(
+        self,
+        script: typing.Optional[str] = None,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+    ) -> "AsyncContextManager":
+        """BrowserContext.add_init_script
+
+        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:
+
+        ```py
+        # in your playwright script, assuming the preload.js file is in same directory.
+        await browser_context.add_init_script(path=\"preload.js\")
+        ```
+
+        **NOTE** The order of evaluation of multiple scripts installed via `browser_context.add_init_script()` and
+        `page.add_init_script()` is not defined.
+
+        Parameters
+        ----------
+        script : Union[str, None]
+            Script to be evaluated in all pages in the browser context. Optional.
+        path : Union[pathlib.Path, str, None]
+            Path to the JavaScript file. If `path` is a relative path, then it is resolved relative to the current working
+            directory. Optional.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.add_init_script(script=script, path=path)
+        )
+
+    async def expose_binding(
+        self, name: str, callback: typing.Callable
+    ) -> "AsyncContextManager":
+        """BrowserContext.expose_binding
+
+        The method adds a function called `name` on the `window` object of every frame in every page in the context. When
+        called, the function executes `callback` and returns a [Promise] which resolves to the return value of `callback`.
+        If the `callback` returns a [Promise], it will be awaited.
+
+        The first argument of the `callback` function contains information about the caller: `{ browserContext:
+        BrowserContext, page: Page, frame: Frame }`.
+
+        See `page.expose_binding()` for page-only version.
+
+        **Usage**
+
+        An example of exposing page URL to all frames in all pages in the context:
+
+        ```py
+        import asyncio
+        from playwright.async_api import async_playwright, Playwright
+
+        async def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = await webkit.launch(headless=False)
+            context = await browser.new_context()
+            await context.expose_binding(\"pageURL\", lambda source: source[\"page\"].url)
+            page = await context.new_page()
+            await page.set_content(\"\"\"
+            <script>
+              async function onClick() {
+                document.querySelector('div').textContent = await window.pageURL();
+              }
+            </script>
+            <button onclick=\"onClick()\">Click me</button>
+            <div></div>
+            \"\"\")
+            await page.get_by_role(\"button\").click()
+
+        async def main():
+            async with async_playwright() as playwright:
+                await run(playwright)
+        asyncio.run(main())
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Name of the function on the window object.
+        callback : Callable
+            Callback function that will be called in the Playwright's context.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.expose_binding(
+                name=name, callback=self._wrap_handler(callback)
+            )
+        )
+
+    async def expose_function(
+        self, name: str, callback: typing.Callable
+    ) -> "AsyncContextManager":
+        """BrowserContext.expose_function
+
+        The method adds a function called `name` on the `window` object of every frame in every page in the context. When
+        called, the function executes `callback` and returns a [Promise] which resolves to the return value of `callback`.
+
+        If the `callback` returns a [Promise], it will be awaited.
+
+        See `page.expose_function()` for page-only version.
+
+        **Usage**
+
+        An example of adding a `sha256` function to all pages in the context:
+
+        ```py
+        import asyncio
+        import hashlib
+        from playwright.async_api import async_playwright, Playwright
+
+        def sha256(text: str) -> str:
+            m = hashlib.sha256()
+            m.update(bytes(text, \"utf8\"))
+            return m.hexdigest()
+
+        async def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = await webkit.launch(headless=False)
+            context = await browser.new_context()
+            await context.expose_function(\"sha256\", sha256)
+            page = await context.new_page()
+            await page.set_content(\"\"\"
+                <script>
+                  async function onClick() {
+                    document.querySelector('div').textContent = await window.sha256('PLAYWRIGHT');
+                  }
+                </script>
+                <button onclick=\"onClick()\">Click me</button>
+                <div></div>
+            \"\"\")
+            await page.get_by_role(\"button\").click()
+
+        async def main():
+            async with async_playwright() as playwright:
+                await run(playwright)
+        asyncio.run(main())
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Name of the function on the window object.
+        callback : Callable
+            Callback function that will be called in the Playwright's context.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.expose_function(
+                name=name, callback=self._wrap_handler(callback)
+            )
+        )
+
+    async def route(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Union[
+            typing.Callable[["Route"], typing.Any],
+            typing.Callable[["Route", "Request"], typing.Any],
+        ],
+        *,
+        times: typing.Optional[int] = None,
+    ) -> "AsyncContextManager":
+        """BrowserContext.route
+
+        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** `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` to `'block'`.
+
+        **Usage**
+
+        An example of a naive handler that aborts all image requests:
+
+        ```py
+        context = await browser.new_context()
+        page = await context.new_page()
+        await context.route(\"**/*.{png,jpg,jpeg}\", lambda route: route.abort())
+        await page.goto(\"https://example.com\")
+        await browser.close()
+        ```
+
+        or the same snippet using a regex pattern instead:
+
+        ```py
+        context = await browser.new_context()
+        page = await context.new_page()
+        await context.route(re.compile(r\"(\\.png$)|(\\.jpg$)\"), lambda route: route.abort())
+        page = await context.new_page()
+        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:
+
+        ```py
+        async def handle_route(route: Route):
+          if (\"my-string\" in route.request.post_data):
+            await route.fulfill(body=\"mocked-data\")
+          else:
+            await route.continue_()
+        await context.route(\"/api/**\", handle_route)
+        ```
+
+        Page routes (set up with `page.route()`) take precedence over browser context routes when request matches
+        both handlers.
+
+        To remove a route with its handler you can use `browser_context.unroute()`.
+
+        **NOTE** Enabling routing disables http cache.
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            A glob pattern, regex pattern, or predicate that receives a [URL] to match during routing. If `baseURL` is set in
+            the context options and the provided URL is a string that does not start with `*`, it is resolved using the
+            [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.
+        handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
+            handler function to route the request.
+        times : Union[int, None]
+            How often a route should be used. By default it will be used every time.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.route(
+                url=self._wrap_handler(url),
+                handler=self._wrap_handler(handler),
+                times=times,
+            )
+        )
+
+    async def unroute(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Optional[
+            typing.Union[
+                typing.Callable[["Route"], typing.Any],
+                typing.Callable[["Route", "Request"], typing.Any],
+            ]
+        ] = None,
+    ) -> None:
+        """BrowserContext.unroute
+
+        Removes a route created with `browser_context.route()`. When `handler` is not specified, removes all routes
+        for the `url`.
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            A glob pattern, regex pattern, or predicate receiving [URL] used to register a routing with
+            `browser_context.route()`.
+        handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
+            Optional handler function used to register a routing with `browser_context.route()`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.unroute(
+                url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+            )
+        )
+
+    async def route_web_socket(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Callable[["WebSocketRoute"], typing.Any],
+    ) -> None:
+        """BrowserContext.route_web_socket
+
+        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` for more details
+        and examples.
+
+        ```py
+        def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+          if message == \"to-be-blocked\":
+            return
+          ws.send(message)
+
+        async def handler(ws: WebSocketRoute):
+          ws.route_send(lambda message: message_handler(ws, message))
+          await ws.connect()
+
+        await context.route_web_socket(\"/ws\", handler)
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            Only WebSockets with the url matching this pattern will be routed. A string pattern can be relative to the
+            `baseURL` context option.
+        handler : Callable[[WebSocketRoute], Any]
+            Handler function to route the WebSocket.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.route_web_socket(
+                url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+            )
+        )
+
+    async def unroute_all(
+        self,
+        *,
+        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None,
+    ) -> None:
+        """BrowserContext.unroute_all
+
+        Removes all routes created with `browser_context.route()` and `browser_context.route_from_har()`.
+
+        Parameters
+        ----------
+        behavior : Union["default", "ignoreErrors", "wait", None]
+            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
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.unroute_all(behavior=behavior)
+        )
+
+    async def route_from_har(
+        self,
+        har: typing.Union[pathlib.Path, str],
+        *,
+        url: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        not_found: typing.Optional[Literal["abort", "fallback"]] = None,
+        update: typing.Optional[bool] = None,
+        update_content: typing.Optional[Literal["attach", "embed"]] = None,
+        update_mode: typing.Optional[Literal["full", "minimal"]] = None,
+    ) -> None:
+        """BrowserContext.route_from_har
+
+        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/python/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` to `'block'`.
+
+        Parameters
+        ----------
+        har : Union[pathlib.Path, str]
+            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.
+        url : Union[Pattern[str], str, None]
+            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.
+        not_found : Union["abort", "fallback", None]
+            - 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.
+        update : Union[bool, None]
+            If specified, updates the given HAR with the actual network information instead of serving from file. The file is
+            written to disk when `browser_context.close()` is called.
+        update_content : Union["attach", "embed", None]
+            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.
+        update_mode : Union["full", "minimal", None]
+            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`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.route_from_har(
+                har=har,
+                url=url,
+                notFound=not_found,
+                update=update,
+                updateContent=update_content,
+                updateMode=update_mode,
+            )
+        )
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["backgroundpage"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["BrowserContext"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["BrowserContext"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["ConsoleMessage"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Dialog"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Download"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["page"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["pageclose"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["pageload"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["weberror"],
+        predicate: typing.Optional[typing.Callable[["WebError"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["WebError"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Response"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["serviceworker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> AsyncEventContextManager[typing.Any]: ...
+
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager:
+        """BrowserContext.expect_event
+
+        Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+        value. Will throw an error if the context closes before the event is fired. Returns the event data value.
+
+        **Usage**
+
+        ```py
+        async with context.expect_event(\"page\") as event_info:
+            await page.get_by_role(\"button\").click()
+        page = await event_info.value
+        ```
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one would pass into `browserContext.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_event(
+                event=event,
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def is_closed(self) -> bool:
+        """BrowserContext.is_closed
+
+        Indicates that the browser context is in the process of closing or has already been closed.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.is_closed())
+
+    async def close(self, *, reason: typing.Optional[str] = None) -> None:
+        """BrowserContext.close
+
+        Closes the browser context. All the pages that belong to the browser context will be closed.
+
+        **NOTE** The default browser context cannot be closed.
+
+        Parameters
+        ----------
+        reason : Union[str, None]
+            The reason to be reported to the operations interrupted by the context closure.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.close(reason=reason))
+
+    async def storage_state(
+        self,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        indexed_db: typing.Optional[bool] = None,
+    ) -> StorageState:
+        """BrowserContext.storage_state
+
+        Returns storage state for this browser context, contains current cookies, local storage snapshot and IndexedDB
+        snapshot.
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str, None]
+            The file path to save the storage state to. If `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.
+        indexed_db : Union[bool, None]
+            Set to `true` to include [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API) in the storage
+            state snapshot. If your application uses IndexedDB to store authentication tokens, like Firebase Authentication,
+            enable this.
+
+        Returns
+        -------
+        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.storage_state(path=path, indexedDB=indexed_db)
+        )
+
+    async def set_storage_state(
+        self, storage_state: typing.Union[StorageState, str, pathlib.Path]
+    ) -> None:
+        """BrowserContext.set_storage_state
+
+        Clears the existing cookies, local storage and IndexedDB entries for all origins and sets the new storage state.
+
+        **Usage**
+
+        ```py
+        # Load storage state from a file and apply it to the context.
+        await context.set_storage_state(\"state.json\")
+        ```
+
+        Parameters
+        ----------
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}]
+            Learn more about [storage state and auth](../auth.md).
+
+            Populates context with given storage state. This option can be used to initialize context with logged-in
+            information obtained via `browser_context.storage_state()`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_storage_state(storageState=storage_state)
+        )
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["backgroundpage"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["BrowserContext"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "BrowserContext": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "ConsoleMessage": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Dialog": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Download": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["page"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["pageclose"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["pageload"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["weberror"],
+        predicate: typing.Optional[typing.Callable[["WebError"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebError": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Response": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: typing.Literal["serviceworker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Worker": ...
+
+    @typing.overload
+    async def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
+
+    async def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Any:
+        """BrowserContext.wait_for_event
+
+        **NOTE** In most cases, you should use `browser_context.expect_event()`.
+
+        Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function
+        and waits for `predicate(event)` to return a truthy value. Will throw an error if the browser context is closed
+        before the `event` is fired.
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for_event(
+                event=event,
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            )
+        )
+
+    def expect_console_message(
+        self,
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["ConsoleMessage"]:
+        """BrowserContext.expect_console_message
+
+        Performs action and waits for a `ConsoleMessage` to be logged by in the pages in the context. If predicate is
+        provided, it passes `ConsoleMessage` value into the `predicate` function and waits for `predicate(message)` to
+        return a truthy value. Will throw an error if the page is closed before the `browser_context.on('console')` event
+        is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[ConsoleMessage], bool], None]
+            Receives the `ConsoleMessage` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[ConsoleMessage]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_console_message(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    def expect_page(
+        self,
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> AsyncEventContextManager["Page"]:
+        """BrowserContext.expect_page
+
+        Performs action and waits for a new `Page` to be created in the context. If predicate is provided, it passes `Page`
+        value into the `predicate` function and waits for `predicate(event)` to return a truthy value. Will throw an error
+        if the context closes before new `Page` is created.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[Page], bool], None]
+            Receives the `Page` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[Page]
+        """
+
+        return AsyncEventContextManager(
+            self._impl_obj.expect_page(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future
+        )
+
+    async def new_cdp_session(
+        self, page: typing.Union["Page", "Frame"]
+    ) -> "CDPSession":
+        """BrowserContext.new_cdp_session
+
+        **NOTE** CDP sessions are only supported on Chromium-based browsers.
+
+        Returns the newly created session.
+
+        Parameters
+        ----------
+        page : Union[Frame, Page]
+            Target to create new session for. For backwards-compatibility, this parameter is named `page`, but it can be a
+            `Page` or `Frame` type.
+
+        Returns
+        -------
+        CDPSession
+        """
+
+        return mapping.from_impl(await self._impl_obj.new_cdp_session(page=page))
+
+
+mapping.register(BrowserContextImpl, BrowserContext)
+
+
+class CDPSession(AsyncBase):
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[
+            ["CDPSession"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when the session is closed, either because the target was closed or `session.detach()` was called.
+        """
+
+    @typing.overload
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None: ...
+
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["close"],
+        f: typing.Callable[
+            ["CDPSession"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when the session is closed, either because the target was closed or `session.detach()` was called.
+        """
+
+    @typing.overload
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None: ...
+
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().once(event=event, f=f)
+
+    async def send(
+        self, method: str, params: typing.Optional[typing.Dict] = None
+    ) -> typing.Dict:
+        """CDPSession.send
+
+        Parameters
+        ----------
+        method : str
+            Protocol method name.
+        params : Union[Dict, None]
+            Optional method parameters.
+
+        Returns
+        -------
+        Dict
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.send(method=method, params=mapping.to_impl(params))
+        )
+
+    async def detach(self) -> None:
+        """CDPSession.detach
+
+        Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be
+        used to send messages.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.detach())
+
+
+mapping.register(CDPSessionImpl, CDPSession)
+
+
+class Browser(AsyncContextManager):
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["context"],
+        f: typing.Callable[
+            ["BrowserContext"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when a new browser context is created."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["disconnected"],
+        f: typing.Callable[["Browser"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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()` method was called."""
+
+    def on(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["context"],
+        f: typing.Callable[
+            ["BrowserContext"], "typing.Union[typing.Awaitable[None], None]"
+        ],
+    ) -> None:
+        """
+        Emitted when a new browser context is created."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["disconnected"],
+        f: typing.Callable[["Browser"], "typing.Union[typing.Awaitable[None], None]"],
+    ) -> None:
+        """
+        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()` method was called."""
+
+    def once(
+        self,
+        event: str,
+        f: typing.Callable[..., typing.Union[typing.Awaitable[None], None]],
+    ) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def contexts(self) -> typing.List["BrowserContext"]:
+        """Browser.contexts
+
+        Returns an array of all open browser contexts. In a newly created browser, this will return zero browser contexts.
+
+        **Usage**
+
+        ```py
+        browser = await pw.webkit.launch()
+        print(len(browser.contexts)) # prints `0`
+        context = await browser.new_context()
+        print(len(browser.contexts)) # prints `1`
+        ```
+
+        Returns
+        -------
+        List[BrowserContext]
+        """
+        return mapping.from_impl_list(self._impl_obj.contexts)
+
+    @property
+    def browser_type(self) -> "BrowserType":
+        """Browser.browser_type
+
+        Get the browser type (chromium, firefox or webkit) that the browser belongs to.
+
+        Returns
+        -------
+        BrowserType
+        """
+        return mapping.from_impl(self._impl_obj.browser_type)
+
+    @property
+    def version(self) -> str:
+        """Browser.version
+
+        Returns the browser version.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.version)
+
+    def is_connected(self) -> bool:
+        """Browser.is_connected
+
+        Indicates that the browser is connected.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.is_connected())
+
+    async def new_context(
+        self,
+        *,
+        viewport: typing.Optional[ViewportSize] = None,
+        screen: typing.Optional[ViewportSize] = None,
+        no_viewport: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        java_script_enabled: typing.Optional[bool] = None,
+        bypass_csp: typing.Optional[bool] = None,
+        user_agent: typing.Optional[str] = None,
+        locale: typing.Optional[str] = None,
+        timezone_id: typing.Optional[str] = None,
+        geolocation: typing.Optional[Geolocation] = None,
+        permissions: typing.Optional[typing.Sequence[str]] = None,
+        extra_http_headers: typing.Optional[typing.Dict[str, str]] = None,
+        offline: typing.Optional[bool] = None,
+        http_credentials: typing.Optional[HttpCredentials] = None,
+        device_scale_factor: typing.Optional[float] = None,
+        is_mobile: typing.Optional[bool] = None,
+        has_touch: typing.Optional[bool] = None,
+        color_scheme: typing.Optional[
+            Literal["dark", "light", "no-preference", "null"]
+        ] = None,
+        reduced_motion: typing.Optional[
+            Literal["no-preference", "null", "reduce"]
+        ] = None,
+        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
+        accept_downloads: typing.Optional[bool] = None,
+        default_browser_type: typing.Optional[str] = None,
+        proxy: typing.Optional[ProxySettings] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_har_omit_content: typing.Optional[bool] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_video_size: typing.Optional[ViewportSize] = None,
+        storage_state: typing.Optional[
+            typing.Union[StorageState, str, pathlib.Path]
+        ] = None,
+        base_url: typing.Optional[str] = None,
+        strict_selectors: typing.Optional[bool] = None,
+        service_workers: typing.Optional[Literal["allow", "block"]] = None,
+        record_har_url_filter: typing.Optional[
+            typing.Union[typing.Pattern[str], str]
+        ] = None,
+        record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+    ) -> "BrowserContext":
+        """Browser.new_context
+
+        Creates a new browser context. It won't share cookies/cache with other browser contexts.
+
+        **NOTE** If directly using this method to create `BrowserContext`s, it is best practice to explicitly close the
+        returned context via `browser_context.close()` when your code is done with the `BrowserContext`, and before
+        calling `browser.close()`. This will ensure the `context` is closed gracefully and any artifacts—like HARs
+        and videos—are fully flushed and saved.
+
+        **Usage**
+
+        ```py
+        browser = await playwright.firefox.launch() # or \"chromium\" or \"webkit\".
+        # create a new incognito browser context.
+        context = await browser.new_context()
+        # create a new page in a pristine context.
+        page = await context.new_page()
+        await page.goto(\"https://example.com\")
+
+        # gracefully close up everything
+        await context.close()
+        await browser.close()
+        ```
+
+        Parameters
+        ----------
+        viewport : Union[{width: int, height: int}, None]
+            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `no_viewport` disables the fixed
+            viewport. Learn more about [viewport emulation](../emulation.md#viewport).
+        screen : Union[{width: int, height: int}, None]
+            Emulates consistent window screen size available inside web page via `window.screen`. Is only used when the
+            `viewport` is set.
+        no_viewport : Union[bool, None]
+            Does not enforce fixed viewport, allows resizing window in the headed mode.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        java_script_enabled : Union[bool, None]
+            Whether or not to enable JavaScript in the context. Defaults to `true`. Learn more about
+            [disabling JavaScript](../emulation.md#javascript-enabled).
+        bypass_csp : Union[bool, None]
+            Toggles bypassing page's Content-Security-Policy. Defaults to `false`.
+        user_agent : Union[str, None]
+            Specific user agent to use in this context.
+        locale : Union[str, None]
+            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](../emulation.md#locale--timezone).
+        timezone_id : Union[str, None]
+            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.
+        geolocation : Union[{latitude: float, longitude: float, accuracy: Union[float, None]}, None]
+        permissions : Union[Sequence[str], None]
+            A list of permissions to grant to all pages in this context. See `browser_context.grant_permissions()` for
+            more details. Defaults to none.
+        extra_http_headers : Union[Dict[str, str], None]
+            An object containing additional HTTP headers to be sent with every request. Defaults to none.
+        offline : Union[bool, None]
+            Whether to emulate network being offline. Defaults to `false`. Learn more about
+            [network emulation](../emulation.md#offline).
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
+            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.
+        device_scale_factor : Union[float, None]
+            Specify device scale factor (can be thought of as dpr). Defaults to `1`. Learn more about
+            [emulating devices with device scale factor](../emulation.md#devices).
+        is_mobile : Union[bool, None]
+            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](../emulation.md#ismobile).
+        has_touch : Union[bool, None]
+            Specifies if viewport supports touch events. Defaults to false. Learn more about
+            [mobile emulation](../emulation.md#devices).
+        color_scheme : Union["dark", "light", "no-preference", "null", None]
+            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.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
+        reduced_motion : Union["no-preference", "null", "reduce", None]
+            Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        forced_colors : Union["active", "none", "null", None]
+            Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        accept_downloads : Union[bool, None]
+            Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.
+        proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
+            Network proxy settings to use with this context. Defaults to none.
+        record_har_path : Union[pathlib.Path, str, None]
+            Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into the specified HAR file
+            on the filesystem. If not specified, the HAR is not recorded. Make sure to call `browser_context.close()`
+            for the HAR to be saved.
+        record_har_omit_content : Union[bool, None]
+            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
+        record_video_dir : Union[pathlib.Path, str, None]
+            Enables video recording for all pages into the specified directory. If not specified videos are not recorded. Make
+            sure to call `browser_context.close()` for videos to be saved.
+        record_video_size : Union[{width: int, height: int}, None]
+            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.
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
+            Learn more about [storage state and auth](../auth.md).
+
+            Populates context with given storage state. This option can be used to initialize context with logged-in
+            information obtained via `browser_context.storage_state()`.
+        base_url : Union[str, None]
+            When using `page.goto()`, `page.route()`, `page.wait_for_url()`,
+            `page.expect_request()`, or `page.expect_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`
+        strict_selectors : Union[bool, None]
+            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` to learn
+            more about the strict mode.
+        service_workers : Union["allow", "block", None]
+            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.
+        record_har_url_filter : Union[Pattern[str], str, None]
+        record_har_mode : Union["full", "minimal", None]
+            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`.
+        record_har_content : Union["attach", "embed", "omit", None]
+            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 and all of these files are archived along with the
+            HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            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.
+
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
+
+            **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`.
+
+
+        Returns
+        -------
+        BrowserContext
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.new_context(
+                viewport=viewport,
+                screen=screen,
+                noViewport=no_viewport,
+                ignoreHTTPSErrors=ignore_https_errors,
+                javaScriptEnabled=java_script_enabled,
+                bypassCSP=bypass_csp,
+                userAgent=user_agent,
+                locale=locale,
+                timezoneId=timezone_id,
+                geolocation=geolocation,
+                permissions=mapping.to_impl(permissions),
+                extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                offline=offline,
+                httpCredentials=http_credentials,
+                deviceScaleFactor=device_scale_factor,
+                isMobile=is_mobile,
+                hasTouch=has_touch,
+                colorScheme=color_scheme,
+                reducedMotion=reduced_motion,
+                forcedColors=forced_colors,
+                contrast=contrast,
+                acceptDownloads=accept_downloads,
+                defaultBrowserType=default_browser_type,
+                proxy=proxy,
+                recordHarPath=record_har_path,
+                recordHarOmitContent=record_har_omit_content,
+                recordVideoDir=record_video_dir,
+                recordVideoSize=record_video_size,
+                storageState=storage_state,
+                baseURL=base_url,
+                strictSelectors=strict_selectors,
+                serviceWorkers=service_workers,
+                recordHarUrlFilter=record_har_url_filter,
+                recordHarMode=record_har_mode,
+                recordHarContent=record_har_content,
+                clientCertificates=client_certificates,
+            )
+        )
+
+    async def new_page(
+        self,
+        *,
+        viewport: typing.Optional[ViewportSize] = None,
+        screen: typing.Optional[ViewportSize] = None,
+        no_viewport: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        java_script_enabled: typing.Optional[bool] = None,
+        bypass_csp: typing.Optional[bool] = None,
+        user_agent: typing.Optional[str] = None,
+        locale: typing.Optional[str] = None,
+        timezone_id: typing.Optional[str] = None,
+        geolocation: typing.Optional[Geolocation] = None,
+        permissions: typing.Optional[typing.Sequence[str]] = None,
+        extra_http_headers: typing.Optional[typing.Dict[str, str]] = None,
+        offline: typing.Optional[bool] = None,
+        http_credentials: typing.Optional[HttpCredentials] = None,
+        device_scale_factor: typing.Optional[float] = None,
+        is_mobile: typing.Optional[bool] = None,
+        has_touch: typing.Optional[bool] = None,
+        color_scheme: typing.Optional[
+            Literal["dark", "light", "no-preference", "null"]
+        ] = None,
+        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
+        reduced_motion: typing.Optional[
+            Literal["no-preference", "null", "reduce"]
+        ] = None,
+        accept_downloads: typing.Optional[bool] = None,
+        default_browser_type: typing.Optional[str] = None,
+        proxy: typing.Optional[ProxySettings] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_har_omit_content: typing.Optional[bool] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_video_size: typing.Optional[ViewportSize] = None,
+        storage_state: typing.Optional[
+            typing.Union[StorageState, str, pathlib.Path]
+        ] = None,
+        base_url: typing.Optional[str] = None,
+        strict_selectors: typing.Optional[bool] = None,
+        service_workers: typing.Optional[Literal["allow", "block"]] = None,
+        record_har_url_filter: typing.Optional[
+            typing.Union[typing.Pattern[str], str]
+        ] = None,
+        record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+    ) -> "Page":
+        """Browser.new_page
+
+        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.new_context()` followed by the
+        `browser_context.new_page()` to control their exact life times.
+
+        Parameters
+        ----------
+        viewport : Union[{width: int, height: int}, None]
+            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `no_viewport` disables the fixed
+            viewport. Learn more about [viewport emulation](../emulation.md#viewport).
+        screen : Union[{width: int, height: int}, None]
+            Emulates consistent window screen size available inside web page via `window.screen`. Is only used when the
+            `viewport` is set.
+        no_viewport : Union[bool, None]
+            Does not enforce fixed viewport, allows resizing window in the headed mode.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        java_script_enabled : Union[bool, None]
+            Whether or not to enable JavaScript in the context. Defaults to `true`. Learn more about
+            [disabling JavaScript](../emulation.md#javascript-enabled).
+        bypass_csp : Union[bool, None]
+            Toggles bypassing page's Content-Security-Policy. Defaults to `false`.
+        user_agent : Union[str, None]
+            Specific user agent to use in this context.
+        locale : Union[str, None]
+            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](../emulation.md#locale--timezone).
+        timezone_id : Union[str, None]
+            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.
+        geolocation : Union[{latitude: float, longitude: float, accuracy: Union[float, None]}, None]
+        permissions : Union[Sequence[str], None]
+            A list of permissions to grant to all pages in this context. See `browser_context.grant_permissions()` for
+            more details. Defaults to none.
+        extra_http_headers : Union[Dict[str, str], None]
+            An object containing additional HTTP headers to be sent with every request. Defaults to none.
+        offline : Union[bool, None]
+            Whether to emulate network being offline. Defaults to `false`. Learn more about
+            [network emulation](../emulation.md#offline).
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
+            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.
+        device_scale_factor : Union[float, None]
+            Specify device scale factor (can be thought of as dpr). Defaults to `1`. Learn more about
+            [emulating devices with device scale factor](../emulation.md#devices).
+        is_mobile : Union[bool, None]
+            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](../emulation.md#ismobile).
+        has_touch : Union[bool, None]
+            Specifies if viewport supports touch events. Defaults to false. Learn more about
+            [mobile emulation](../emulation.md#devices).
+        color_scheme : Union["dark", "light", "no-preference", "null", None]
+            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.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
+        forced_colors : Union["active", "none", "null", None]
+            Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        reduced_motion : Union["no-preference", "null", "reduce", None]
+            Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        accept_downloads : Union[bool, None]
+            Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.
+        proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
+            Network proxy settings to use with this context. Defaults to none.
+        record_har_path : Union[pathlib.Path, str, None]
+            Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into the specified HAR file
+            on the filesystem. If not specified, the HAR is not recorded. Make sure to call `browser_context.close()`
+            for the HAR to be saved.
+        record_har_omit_content : Union[bool, None]
+            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
+        record_video_dir : Union[pathlib.Path, str, None]
+            Enables video recording for all pages into the specified directory. If not specified videos are not recorded. Make
+            sure to call `browser_context.close()` for videos to be saved.
+        record_video_size : Union[{width: int, height: int}, None]
+            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.
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
+            Learn more about [storage state and auth](../auth.md).
+
+            Populates context with given storage state. This option can be used to initialize context with logged-in
+            information obtained via `browser_context.storage_state()`.
+        base_url : Union[str, None]
+            When using `page.goto()`, `page.route()`, `page.wait_for_url()`,
+            `page.expect_request()`, or `page.expect_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`
+        strict_selectors : Union[bool, None]
+            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` to learn
+            more about the strict mode.
+        service_workers : Union["allow", "block", None]
+            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.
+        record_har_url_filter : Union[Pattern[str], str, None]
+        record_har_mode : Union["full", "minimal", None]
+            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`.
+        record_har_content : Union["attach", "embed", "omit", None]
+            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 and all of these files are archived along with the
+            HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            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.
+
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
+
+            **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`.
+
+
+        Returns
+        -------
+        Page
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.new_page(
+                viewport=viewport,
+                screen=screen,
+                noViewport=no_viewport,
+                ignoreHTTPSErrors=ignore_https_errors,
+                javaScriptEnabled=java_script_enabled,
+                bypassCSP=bypass_csp,
+                userAgent=user_agent,
+                locale=locale,
+                timezoneId=timezone_id,
+                geolocation=geolocation,
+                permissions=mapping.to_impl(permissions),
+                extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                offline=offline,
+                httpCredentials=http_credentials,
+                deviceScaleFactor=device_scale_factor,
+                isMobile=is_mobile,
+                hasTouch=has_touch,
+                colorScheme=color_scheme,
+                forcedColors=forced_colors,
+                contrast=contrast,
+                reducedMotion=reduced_motion,
+                acceptDownloads=accept_downloads,
+                defaultBrowserType=default_browser_type,
+                proxy=proxy,
+                recordHarPath=record_har_path,
+                recordHarOmitContent=record_har_omit_content,
+                recordVideoDir=record_video_dir,
+                recordVideoSize=record_video_size,
+                storageState=storage_state,
+                baseURL=base_url,
+                strictSelectors=strict_selectors,
+                serviceWorkers=service_workers,
+                recordHarUrlFilter=record_har_url_filter,
+                recordHarMode=record_har_mode,
+                recordHarContent=record_har_content,
+                clientCertificates=client_certificates,
+            )
+        )
+
+    async def close(self, *, reason: typing.Optional[str] = None) -> None:
+        """Browser.close
+
+        In case this browser is obtained using `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 `browser_context.close()` on any `BrowserContext` instances you explicitly created earlier
+        using `browser.new_context()` **before** calling `browser.close()`.
+
+        The `Browser` object itself is considered to be disposed and cannot be used anymore.
+
+        Parameters
+        ----------
+        reason : Union[str, None]
+            The reason to be reported to the operations interrupted by the browser closure.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.close(reason=reason))
+
+    async def new_browser_cdp_session(self) -> "CDPSession":
+        """Browser.new_browser_cdp_session
+
+        **NOTE** CDP Sessions are only supported on Chromium-based browsers.
+
+        Returns the newly created browser session.
+
+        Returns
+        -------
+        CDPSession
+        """
+
+        return mapping.from_impl(await self._impl_obj.new_browser_cdp_session())
+
+    async def bind(
+        self,
+        title: str,
+        *,
+        workspace_dir: typing.Optional[str] = None,
+        host: typing.Optional[str] = None,
+        port: typing.Optional[int] = None,
+    ) -> BrowserBindResult:
+        """Browser.bind
+
+        Binds the browser to a named pipe or web socket, making it available for other clients to connect to.
+
+        Parameters
+        ----------
+        title : str
+            Title of the browser server, used for identification.
+        workspace_dir : Union[str, None]
+            Working directory associated with this browser server.
+        host : Union[str, None]
+            Host to bind the web socket server to. When specified, a web socket server is created instead of a named pipe.
+        port : Union[int, None]
+            Port to bind the web socket server to. When specified, a web socket server is created instead of a named pipe. Use
+            `0` to let the OS pick an available port.
+
+        Returns
+        -------
+        {endpoint: str}
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.bind(
+                title=title, workspaceDir=workspace_dir, host=host, port=port
+            )
+        )
+
+    async def unbind(self) -> None:
+        """Browser.unbind
+
+        Unbinds the browser server previously bound with `browser.bind()`.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.unbind())
+
+    async def start_tracing(
+        self,
+        *,
+        page: typing.Optional["Page"] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        screenshots: typing.Optional[bool] = None,
+        categories: typing.Optional[typing.Sequence[str]] = None,
+    ) -> None:
+        """Browser.start_tracing
+
+        **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/python/docs/trace-viewer) could be found
+        [here](https://playwright.dev/python/docs/api/class-tracing).
+
+        You can use `browser.start_tracing()` and `browser.stop_tracing()` to create a trace file that can be
+        opened in Chrome DevTools performance panel.
+
+        **Usage**
+
+        ```py
+        await browser.start_tracing(page, path=\"trace.json\")
+        await page.goto(\"https://www.google.com\")
+        await browser.stop_tracing()
+        ```
+
+        Parameters
+        ----------
+        page : Union[Page, None]
+            Optional, if specified, tracing includes screenshots of the given page.
+        path : Union[pathlib.Path, str, None]
+            A path to write the trace file to.
+        screenshots : Union[bool, None]
+            captures screenshots in the trace.
+        categories : Union[Sequence[str], None]
+            specify custom categories to use instead of default.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.start_tracing(
+                page=page._impl_obj if page else None,
+                path=path,
+                screenshots=screenshots,
+                categories=mapping.to_impl(categories),
+            )
+        )
+
+    async def stop_tracing(self) -> bytes:
+        """Browser.stop_tracing
+
+        **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/python/docs/trace-viewer) could be found
+        [here](https://playwright.dev/python/docs/api/class-tracing).
+
+        Returns the buffer with trace data.
+
+        Returns
+        -------
+        bytes
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.stop_tracing())
+
+
+mapping.register(BrowserImpl, Browser)
+
+
+class BrowserType(AsyncBase):
+
+    @property
+    def name(self) -> str:
+        """BrowserType.name
+
+        Returns browser name. For example: `'chromium'`, `'webkit'` or `'firefox'`.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.name)
+
+    @property
+    def executable_path(self) -> str:
+        """BrowserType.executable_path
+
+        A path where Playwright expects to find a bundled browser executable.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.executable_path)
+
+    async def launch(
+        self,
+        *,
+        executable_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        channel: typing.Optional[str] = None,
+        args: typing.Optional[typing.Sequence[str]] = None,
+        ignore_default_args: typing.Optional[
+            typing.Union[bool, typing.Sequence[str]]
+        ] = None,
+        handle_sigint: typing.Optional[bool] = None,
+        handle_sigterm: typing.Optional[bool] = None,
+        handle_sighup: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        env: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
+        headless: typing.Optional[bool] = None,
+        proxy: typing.Optional[ProxySettings] = None,
+        downloads_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        slow_mo: typing.Optional[float] = None,
+        traces_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        artifacts_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        chromium_sandbox: typing.Optional[bool] = None,
+        firefox_user_prefs: typing.Optional[
+            typing.Dict[str, typing.Union[str, float, bool]]
+        ] = None,
+    ) -> "Browser":
+        """BrowserType.launch
+
+        Returns the browser instance.
+
+        **Usage**
+
+        You can use `ignoreDefaultArgs` to filter out `--mute-audio` from default arguments:
+
+        ```py
+        browser = await playwright.chromium.launch( # or \"firefox\" or \"webkit\".
+            ignore_default_args=[\"--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` 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.
+
+        Parameters
+        ----------
+        executable_path : Union[pathlib.Path, str, None]
+            Path to a browser executable to run instead of the bundled one. If `executablePath` 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.
+        channel : Union[str, None]
+            Browser distribution channel.
+
+            Use "chromium" to [opt in to new headless mode](../browsers.md#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](../browsers.md#google-chrome--microsoft-edge).
+        args : Union[Sequence[str], None]
+            **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/).
+        ignore_default_args : Union[Sequence[str], bool, None]
+            If `true`, Playwright does not pass its own configurations args and only uses the ones from `args`. If an array is
+            given, then filters out the given default arguments. Dangerous option; use with care. Defaults to `false`.
+        handle_sigint : Union[bool, None]
+            Close the browser process on Ctrl-C. Defaults to `true`.
+        handle_sigterm : Union[bool, None]
+            Close the browser process on SIGTERM. Defaults to `true`.
+        handle_sighup : Union[bool, None]
+            Close the browser process on SIGHUP. Defaults to `true`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the browser instance to start. Defaults to `30000` (30 seconds). Pass `0`
+            to disable timeout.
+        env : Union[Dict[str, Union[bool, float, str]], None]
+            Specify environment variables that will be visible to the browser. Defaults to `process.env`.
+        headless : Union[bool, None]
+            Whether to run browser in headless mode. More details for
+            [Chromium](https://developers.google.com/web/updates/2017/04/headless-chrome) and
+            [Firefox](https://hacks.mozilla.org/2017/12/using-headless-mode-in-firefox/). Defaults to `true`.
+        proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
+            Network proxy settings.
+        downloads_path : Union[pathlib.Path, str, None]
+            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.
+        slow_mo : Union[float, None]
+            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going
+            on.
+        traces_dir : Union[pathlib.Path, str, None]
+            If specified, traces are saved into this directory.
+        artifacts_dir : Union[pathlib.Path, str, None]
+            If specified, artifacts (traces, videos, downloads, HAR files, etc.) are saved into this directory. The directory
+            is not cleaned up when the browser closes. If not specified, a temporary directory is used and cleaned up when the
+            browser closes.
+        chromium_sandbox : Union[bool, None]
+            Enable Chromium sandboxing. Defaults to `false`.
+        firefox_user_prefs : Union[Dict[str, Union[bool, float, str]], None]
+            Firefox user preferences. Learn more about the Firefox user preferences at
+            [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox).
+
+            You can also provide a path to a custom [`policies.json` file](https://mozilla.github.io/policy-templates/) via
+            `PLAYWRIGHT_FIREFOX_POLICIES_JSON` environment variable.
+
+        Returns
+        -------
+        Browser
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.launch(
+                executablePath=executable_path,
+                channel=channel,
+                args=mapping.to_impl(args),
+                ignoreDefaultArgs=mapping.to_impl(ignore_default_args),
+                handleSIGINT=handle_sigint,
+                handleSIGTERM=handle_sigterm,
+                handleSIGHUP=handle_sighup,
+                timeout=to_milliseconds(timeout),
+                env=mapping.to_impl(env),
+                headless=headless,
+                proxy=proxy,
+                downloadsPath=downloads_path,
+                slowMo=slow_mo,
+                tracesDir=traces_dir,
+                artifactsDir=artifacts_dir,
+                chromiumSandbox=chromium_sandbox,
+                firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
+            )
+        )
+
+    async def launch_persistent_context(
+        self,
+        user_data_dir: typing.Union[str, pathlib.Path],
+        *,
+        channel: typing.Optional[str] = None,
+        executable_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        args: typing.Optional[typing.Sequence[str]] = None,
+        ignore_default_args: typing.Optional[
+            typing.Union[bool, typing.Sequence[str]]
+        ] = None,
+        handle_sigint: typing.Optional[bool] = None,
+        handle_sigterm: typing.Optional[bool] = None,
+        handle_sighup: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        env: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
+        headless: typing.Optional[bool] = None,
+        proxy: typing.Optional[ProxySettings] = None,
+        downloads_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        slow_mo: typing.Optional[float] = None,
+        viewport: typing.Optional[ViewportSize] = None,
+        screen: typing.Optional[ViewportSize] = None,
+        no_viewport: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        java_script_enabled: typing.Optional[bool] = None,
+        bypass_csp: typing.Optional[bool] = None,
+        user_agent: typing.Optional[str] = None,
+        locale: typing.Optional[str] = None,
+        timezone_id: typing.Optional[str] = None,
+        geolocation: typing.Optional[Geolocation] = None,
+        permissions: typing.Optional[typing.Sequence[str]] = None,
+        extra_http_headers: typing.Optional[typing.Dict[str, str]] = None,
+        offline: typing.Optional[bool] = None,
+        http_credentials: typing.Optional[HttpCredentials] = None,
+        device_scale_factor: typing.Optional[float] = None,
+        is_mobile: typing.Optional[bool] = None,
+        has_touch: typing.Optional[bool] = None,
+        color_scheme: typing.Optional[
+            Literal["dark", "light", "no-preference", "null"]
+        ] = None,
+        reduced_motion: typing.Optional[
+            Literal["no-preference", "null", "reduce"]
+        ] = None,
+        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
+        accept_downloads: typing.Optional[bool] = None,
+        traces_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        artifacts_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        chromium_sandbox: typing.Optional[bool] = None,
+        firefox_user_prefs: typing.Optional[
+            typing.Dict[str, typing.Union[str, float, bool]]
+        ] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_har_omit_content: typing.Optional[bool] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_video_size: typing.Optional[ViewportSize] = None,
+        base_url: typing.Optional[str] = None,
+        strict_selectors: typing.Optional[bool] = None,
+        service_workers: typing.Optional[Literal["allow", "block"]] = None,
+        record_har_url_filter: typing.Optional[
+            typing.Union[typing.Pattern[str], str]
+        ] = None,
+        record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+    ) -> "BrowserContext":
+        """BrowserType.launch_persistent_context
+
+        Returns the persistent browser context instance.
+
+        Launches browser that uses persistent storage located at `userDataDir` and returns the only context. Closing this
+        context will automatically close the browser.
+
+        Parameters
+        ----------
+        user_data_dir : Union[pathlib.Path, str]
+            Path to a User Data Directory, which stores browser session data like cookies and local storage. Pass an empty
+            string to create a temporary directory.
+
+            More details for
+            [Chromium](https://chromium.googlesource.com/chromium/src/+/master/docs/user_data_dir.md#introduction) and
+            [Firefox](https://wiki.mozilla.org/Firefox/CommandLineOptions#User_profile). Chromium's user data directory is the
+            **parent** directory of the "Profile Path" seen at `chrome://version`.
+
+            Note that browsers do not allow launching multiple instances with the same User Data Directory.
+
+            **NOTE** Chromium/Chrome: Due to recent Chrome policy changes, automating the default Chrome user profile is not
+            supported. Pointing `userDataDir` to Chrome's main "User Data" directory (the profile used for your regular
+            browsing) may result in pages not loading or the browser exiting. Create and use a separate directory (for example,
+            an empty folder) as your automation profile instead. See https://developer.chrome.com/blog/remote-debugging-port
+            for details.
+
+        channel : Union[str, None]
+            Browser distribution channel.
+
+            Use "chromium" to [opt in to new headless mode](../browsers.md#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](../browsers.md#google-chrome--microsoft-edge).
+        executable_path : Union[pathlib.Path, str, None]
+            Path to a browser executable to run instead of the bundled one. If `executablePath` 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.
+        args : Union[Sequence[str], None]
+            **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/).
+        ignore_default_args : Union[Sequence[str], bool, None]
+            If `true`, Playwright does not pass its own configurations args and only uses the ones from `args`. If an array is
+            given, then filters out the given default arguments. Dangerous option; use with care. Defaults to `false`.
+        handle_sigint : Union[bool, None]
+            Close the browser process on Ctrl-C. Defaults to `true`.
+        handle_sigterm : Union[bool, None]
+            Close the browser process on SIGTERM. Defaults to `true`.
+        handle_sighup : Union[bool, None]
+            Close the browser process on SIGHUP. Defaults to `true`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the browser instance to start. Defaults to `30000` (30 seconds). Pass `0`
+            to disable timeout.
+        env : Union[Dict[str, Union[bool, float, str]], None]
+            Specify environment variables that will be visible to the browser. Defaults to `process.env`.
+        headless : Union[bool, None]
+            Whether to run browser in headless mode. More details for
+            [Chromium](https://developers.google.com/web/updates/2017/04/headless-chrome) and
+            [Firefox](https://hacks.mozilla.org/2017/12/using-headless-mode-in-firefox/). Defaults to `true`.
+        proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
+            Network proxy settings.
+        downloads_path : Union[pathlib.Path, str, None]
+            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.
+        slow_mo : Union[float, None]
+            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going
+            on.
+        viewport : Union[{width: int, height: int}, None]
+            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `no_viewport` disables the fixed
+            viewport. Learn more about [viewport emulation](../emulation.md#viewport).
+        screen : Union[{width: int, height: int}, None]
+            Emulates consistent window screen size available inside web page via `window.screen`. Is only used when the
+            `viewport` is set.
+        no_viewport : Union[bool, None]
+            Does not enforce fixed viewport, allows resizing window in the headed mode.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        java_script_enabled : Union[bool, None]
+            Whether or not to enable JavaScript in the context. Defaults to `true`. Learn more about
+            [disabling JavaScript](../emulation.md#javascript-enabled).
+        bypass_csp : Union[bool, None]
+            Toggles bypassing page's Content-Security-Policy. Defaults to `false`.
+        user_agent : Union[str, None]
+            Specific user agent to use in this context.
+        locale : Union[str, None]
+            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](../emulation.md#locale--timezone).
+        timezone_id : Union[str, None]
+            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.
+        geolocation : Union[{latitude: float, longitude: float, accuracy: Union[float, None]}, None]
+        permissions : Union[Sequence[str], None]
+            A list of permissions to grant to all pages in this context. See `browser_context.grant_permissions()` for
+            more details. Defaults to none.
+        extra_http_headers : Union[Dict[str, str], None]
+            An object containing additional HTTP headers to be sent with every request. Defaults to none.
+        offline : Union[bool, None]
+            Whether to emulate network being offline. Defaults to `false`. Learn more about
+            [network emulation](../emulation.md#offline).
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
+            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.
+        device_scale_factor : Union[float, None]
+            Specify device scale factor (can be thought of as dpr). Defaults to `1`. Learn more about
+            [emulating devices with device scale factor](../emulation.md#devices).
+        is_mobile : Union[bool, None]
+            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](../emulation.md#ismobile).
+        has_touch : Union[bool, None]
+            Specifies if viewport supports touch events. Defaults to false. Learn more about
+            [mobile emulation](../emulation.md#devices).
+        color_scheme : Union["dark", "light", "no-preference", "null", None]
+            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.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
+        reduced_motion : Union["no-preference", "null", "reduce", None]
+            Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        forced_colors : Union["active", "none", "null", None]
+            Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        accept_downloads : Union[bool, None]
+            Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.
+        traces_dir : Union[pathlib.Path, str, None]
+            If specified, traces are saved into this directory.
+        artifacts_dir : Union[pathlib.Path, str, None]
+            If specified, artifacts (traces, videos, downloads, HAR files, etc.) are saved into this directory. The directory
+            is not cleaned up when the browser closes. If not specified, a temporary directory is used and cleaned up when the
+            browser closes.
+        chromium_sandbox : Union[bool, None]
+            Enable Chromium sandboxing. Defaults to `false`.
+        firefox_user_prefs : Union[Dict[str, Union[bool, float, str]], None]
+            Firefox user preferences. Learn more about the Firefox user preferences at
+            [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox).
+
+            You can also provide a path to a custom [`policies.json` file](https://mozilla.github.io/policy-templates/) via
+            `PLAYWRIGHT_FIREFOX_POLICIES_JSON` environment variable.
+        record_har_path : Union[pathlib.Path, str, None]
+            Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into the specified HAR file
+            on the filesystem. If not specified, the HAR is not recorded. Make sure to call `browser_context.close()`
+            for the HAR to be saved.
+        record_har_omit_content : Union[bool, None]
+            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
+        record_video_dir : Union[pathlib.Path, str, None]
+            Enables video recording for all pages into the specified directory. If not specified videos are not recorded. Make
+            sure to call `browser_context.close()` for videos to be saved.
+        record_video_size : Union[{width: int, height: int}, None]
+            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.
+        base_url : Union[str, None]
+            When using `page.goto()`, `page.route()`, `page.wait_for_url()`,
+            `page.expect_request()`, or `page.expect_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`
+        strict_selectors : Union[bool, None]
+            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` to learn
+            more about the strict mode.
+        service_workers : Union["allow", "block", None]
+            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.
+        record_har_url_filter : Union[Pattern[str], str, None]
+        record_har_mode : Union["full", "minimal", None]
+            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`.
+        record_har_content : Union["attach", "embed", "omit", None]
+            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 and all of these files are archived along with the
+            HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            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.
+
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
+
+            **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`.
+
+
+        Returns
+        -------
+        BrowserContext
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.launch_persistent_context(
+                userDataDir=user_data_dir,
+                channel=channel,
+                executablePath=executable_path,
+                args=mapping.to_impl(args),
+                ignoreDefaultArgs=mapping.to_impl(ignore_default_args),
+                handleSIGINT=handle_sigint,
+                handleSIGTERM=handle_sigterm,
+                handleSIGHUP=handle_sighup,
+                timeout=to_milliseconds(timeout),
+                env=mapping.to_impl(env),
+                headless=headless,
+                proxy=proxy,
+                downloadsPath=downloads_path,
+                slowMo=slow_mo,
+                viewport=viewport,
+                screen=screen,
+                noViewport=no_viewport,
+                ignoreHTTPSErrors=ignore_https_errors,
+                javaScriptEnabled=java_script_enabled,
+                bypassCSP=bypass_csp,
+                userAgent=user_agent,
+                locale=locale,
+                timezoneId=timezone_id,
+                geolocation=geolocation,
+                permissions=mapping.to_impl(permissions),
+                extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                offline=offline,
+                httpCredentials=http_credentials,
+                deviceScaleFactor=device_scale_factor,
+                isMobile=is_mobile,
+                hasTouch=has_touch,
+                colorScheme=color_scheme,
+                reducedMotion=reduced_motion,
+                forcedColors=forced_colors,
+                contrast=contrast,
+                acceptDownloads=accept_downloads,
+                tracesDir=traces_dir,
+                artifactsDir=artifacts_dir,
+                chromiumSandbox=chromium_sandbox,
+                firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
+                recordHarPath=record_har_path,
+                recordHarOmitContent=record_har_omit_content,
+                recordVideoDir=record_video_dir,
+                recordVideoSize=record_video_size,
+                baseURL=base_url,
+                strictSelectors=strict_selectors,
+                serviceWorkers=service_workers,
+                recordHarUrlFilter=record_har_url_filter,
+                recordHarMode=record_har_mode,
+                recordHarContent=record_har_content,
+                clientCertificates=client_certificates,
+            )
+        )
+
+    async def connect_over_cdp(
+        self,
+        endpoint_url: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        slow_mo: typing.Optional[float] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        is_local: typing.Optional[bool] = None,
+        no_defaults: typing.Optional[bool] = None,
+    ) -> "Browser":
+        """BrowserType.connect_over_cdp
+
+        This method attaches Playwright to an existing browser instance using the Chrome DevTools Protocol.
+
+        The default browser context is accessible via `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
+        `browser_type.connect()`. If you are experiencing issues or attempting to use advanced functionality, you
+        probably want to use `browser_type.connect()`.
+
+        **Usage**
+
+        ```py
+        browser = await playwright.chromium.connect_over_cdp(\"http://localhost:9222\")
+        default_context = browser.contexts[0]
+        page = default_context.pages[0]
+        ```
+
+        Parameters
+        ----------
+        endpoint_url : str
+            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`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the connection to be established. Defaults to `30000` (30 seconds). Pass
+            `0` to disable timeout.
+        slow_mo : Union[float, None]
+            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going
+            on. Defaults to 0.
+        headers : Union[Dict[str, str], None]
+            Additional HTTP headers to be sent with connect request. Optional.
+        is_local : Union[bool, None]
+            Tells Playwright that it runs on the same host as the CDP server. It will enable certain optimizations that rely
+            upon the file system being the same between Playwright and the Browser.
+        no_defaults : Union[bool, None]
+            When true, Playwright will not apply its default overrides to the existing default browser context. Specifically,
+            `acceptDownloads` is left at the browser's setting, focus emulation is not enabled, and media emulation options
+            (such as `colorScheme`, `reducedMotion`, `forcedColors`, and `contrast`) are not applied. Useful when attaching to
+            a user's daily-driver browser where these overrides would interfere with existing browser state. New contexts
+            created via `browser.new_context()` are not affected. Defaults to `false`.
+
+        Returns
+        -------
+        Browser
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.connect_over_cdp(
+                endpointURL=endpoint_url,
+                timeout=to_milliseconds(timeout),
+                slowMo=slow_mo,
+                headers=mapping.to_impl(headers),
+                isLocal=is_local,
+                noDefaults=no_defaults,
+            )
+        )
+
+    async def connect(
+        self,
+        endpoint: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        slow_mo: typing.Optional[float] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        expose_network: typing.Optional[str] = None,
+    ) -> "Browser":
+        """BrowserType.connect
+
+        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).
+
+        Parameters
+        ----------
+        endpoint : str
+            A Playwright browser websocket endpoint to connect to. You obtain this endpoint via `BrowserServer.wsEndpoint`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the connection to be established. Defaults to `0` (no timeout).
+        slow_mo : Union[float, None]
+            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going
+            on. Defaults to 0.
+        headers : Union[Dict[str, str], None]
+            Additional HTTP headers to be sent with web socket connect request. Optional.
+        expose_network : Union[str, None]
+            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.
+
+        Returns
+        -------
+        Browser
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.connect(
+                endpoint=endpoint,
+                timeout=to_milliseconds(timeout),
+                slowMo=slow_mo,
+                headers=mapping.to_impl(headers),
+                exposeNetwork=expose_network,
+            )
+        )
+
+
+mapping.register(BrowserTypeImpl, BrowserType)
+
+
+class Playwright(AsyncBase):
+
+    @property
+    def devices(self) -> typing.Dict:
+        """Playwright.devices
+
+        Returns a dictionary of devices to be used with `browser.new_context()` or `browser.new_page()`.
+
+        ```py
+        import asyncio
+        from playwright.async_api import async_playwright, Playwright
+
+        async def run(playwright: Playwright):
+            webkit = playwright.webkit
+            iphone = playwright.devices[\"iPhone 6\"]
+            browser = await webkit.launch()
+            context = await browser.new_context(**iphone)
+            page = await context.new_page()
+            await page.goto(\"http://example.com\")
+            # other actions...
+            await browser.close()
+
+        async def main():
+            async with async_playwright() as playwright:
+                await run(playwright)
+        asyncio.run(main())
+        ```
+
+        Returns
+        -------
+        Dict
+        """
+        return mapping.from_maybe_impl(self._impl_obj.devices)
+
+    @property
+    def selectors(self) -> "Selectors":
+        """Playwright.selectors
+
+        Selectors can be used to install custom selector engines. See [extensibility](https://playwright.dev/python/docs/extensibility) for more
+        information.
+
+        Returns
+        -------
+        Selectors
+        """
+        return mapping.from_impl(self._impl_obj.selectors)
+
+    @property
+    def chromium(self) -> "BrowserType":
+        """Playwright.chromium
+
+        This object can be used to launch or connect to Chromium, returning instances of `Browser`.
+
+        Returns
+        -------
+        BrowserType
+        """
+        return mapping.from_impl(self._impl_obj.chromium)
+
+    @property
+    def firefox(self) -> "BrowserType":
+        """Playwright.firefox
+
+        This object can be used to launch or connect to Firefox, returning instances of `Browser`.
+
+        Returns
+        -------
+        BrowserType
+        """
+        return mapping.from_impl(self._impl_obj.firefox)
+
+    @property
+    def webkit(self) -> "BrowserType":
+        """Playwright.webkit
+
+        This object can be used to launch or connect to WebKit, returning instances of `Browser`.
+
+        Returns
+        -------
+        BrowserType
+        """
+        return mapping.from_impl(self._impl_obj.webkit)
+
+    @property
+    def request(self) -> "APIRequest":
+        """Playwright.request
+
+        Exposes API that can be used for the Web API testing.
+
+        Returns
+        -------
+        APIRequest
+        """
+        return mapping.from_impl(self._impl_obj.request)
+
+    def __getitem__(self, value: str) -> "BrowserType":
+
+        return mapping.from_impl(self._impl_obj.__getitem__(value=value))
+
+    async def stop(self) -> None:
+        """Playwright.stop
+
+        Terminates this instance of Playwright in case it was created bypassing the Python context manager. This is useful
+        in REPL applications.
+
+        ```py
+        from playwright.sync_api import sync_playwright
+
+        playwright = sync_playwright().start()
+
+        browser = playwright.chromium.launch()
+        page = browser.new_page()
+        page.goto(\"https://playwright.dev/\")
+        page.screenshot(path=\"example.png\")
+        browser.close()
+
+        playwright.stop()
+        ```
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.stop())
+
+
+mapping.register(PlaywrightImpl, Playwright)
+
+
+class Tracing(AsyncBase):
+
+    async def start(
+        self,
+        *,
+        name: typing.Optional[str] = None,
+        title: typing.Optional[str] = None,
+        snapshots: typing.Optional[bool] = None,
+        screenshots: typing.Optional[bool] = None,
+        sources: typing.Optional[bool] = None,
+        live: typing.Optional[bool] = None,
+    ) -> None:
+        """Tracing.start
+
+        Start tracing.
+
+        **NOTE** You probably want to
+        [enable tracing in your config file](https://playwright.dev/docs/api/class-testoptions#test-options-trace) instead
+        of using `Tracing.start`.
+
+        The `context.tracing` API captures browser operations and network activity, but it doesn't record test assertions
+        (like `expect` calls). We recommend
+        [enabling tracing through Playwright Test configuration](https://playwright.dev/docs/api/class-testoptions#test-options-trace),
+        which includes those assertions and provides a more complete trace for debugging test failures.
+
+        **Usage**
+
+        ```py
+        await context.tracing.start(screenshots=True, snapshots=True)
+        page = await context.new_page()
+        await page.goto(\"https://playwright.dev\")
+        await context.tracing.stop(path = \"trace.zip\")
+        ```
+
+        Parameters
+        ----------
+        name : Union[str, None]
+            If specified, intermediate trace files are going to be saved into the files with the given name prefix inside the
+            `tracesDir` directory specified in `browser_type.launch()`. To specify the final trace zip file name, you
+            need to pass `path` option to `tracing.stop()` instead.
+        title : Union[str, None]
+            Trace name to be shown in the Trace Viewer.
+        snapshots : Union[bool, None]
+            If this option is true tracing will
+            - capture DOM snapshot on every action
+            - record network activity
+        screenshots : Union[bool, None]
+            Whether to capture screenshots during tracing. Screenshots are used to build a timeline preview.
+        sources : Union[bool, None]
+            Whether to include source files for trace actions.
+        live : Union[bool, None]
+            When enabled, the trace is written to an unarchived file that is updated in real time as actions occur, instead of
+            caching changes and archiving them into a zip file at the end. This is useful for live trace viewing during test
+            execution.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.start(
+                name=name,
+                title=title,
+                snapshots=snapshots,
+                screenshots=screenshots,
+                sources=sources,
+                live=live,
+            )
+        )
+
+    async def start_chunk(
+        self, *, title: typing.Optional[str] = None, name: typing.Optional[str] = None
+    ) -> None:
+        """Tracing.start_chunk
+
+        Start a new trace chunk. If you'd like to record multiple traces on the same `BrowserContext`, use
+        `tracing.start()` once, and then create multiple trace chunks with `tracing.start_chunk()` and
+        `tracing.stop_chunk()`.
+
+        **Usage**
+
+        ```py
+        await context.tracing.start(screenshots=True, snapshots=True)
+        page = await context.new_page()
+        await page.goto(\"https://playwright.dev\")
+
+        await context.tracing.start_chunk()
+        await page.get_by_text(\"Get Started\").click()
+        # Everything between start_chunk and stop_chunk will be recorded in the trace.
+        await context.tracing.stop_chunk(path = \"trace1.zip\")
+
+        await context.tracing.start_chunk()
+        await page.goto(\"http://example.com\")
+        # Save a second trace file with different actions.
+        await context.tracing.stop_chunk(path = \"trace2.zip\")
+        ```
+
+        Parameters
+        ----------
+        title : Union[str, None]
+            Trace name to be shown in the Trace Viewer.
+        name : Union[str, None]
+            If specified, intermediate trace files are going to be saved into the files with the given name prefix inside the
+            `tracesDir` directory specified in `browser_type.launch()`. To specify the final trace zip file name, you
+            need to pass `path` option to `tracing.stop_chunk()` instead.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.start_chunk(title=title, name=name)
+        )
+
+    async def stop_chunk(
+        self, *, path: typing.Optional[typing.Union[pathlib.Path, str]] = None
+    ) -> None:
+        """Tracing.stop_chunk
+
+        Stop the trace chunk. See `tracing.start_chunk()` for more details about multiple trace chunks.
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str, None]
+            Export trace collected since the last `tracing.start_chunk()` call into the file with the given path.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.stop_chunk(path=path))
+
+    async def stop(
+        self, *, path: typing.Optional[typing.Union[pathlib.Path, str]] = None
+    ) -> None:
+        """Tracing.stop
+
+        Stop tracing.
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str, None]
+            Export trace into the file with the given path.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.stop(path=path))
+
+    async def group(
+        self, name: str, *, location: typing.Optional[TracingGroupLocation] = None
+    ) -> "AsyncContextManager":
+        """Tracing.group
+
+        **NOTE** Use `test.step` instead when available.
+
+        Creates a new group within the trace, assigning any subsequent API calls to this group, until
+        `tracing.group_end()` is called. Groups can be nested and will be visible in the trace viewer.
+
+        **Usage**
+
+        ```py
+        # All actions between group and group_end
+        # will be shown in the trace viewer as a group.
+        page.context.tracing.group(\"Open Playwright.dev > API\")
+        page.goto(\"https://playwright.dev/\")
+        page.get_by_role(\"link\", name=\"API\").click()
+        page.context.tracing.group_end()
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Group name shown in the trace viewer.
+        location : Union[{file: str, line: Union[int, None], column: Union[int, None]}, None]
+            Specifies a custom location for the group to be shown in the trace viewer. Defaults to the location of the
+            `tracing.group()` call.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.group(name=name, location=location)
+        )
+
+    async def group_end(self) -> None:
+        """Tracing.group_end
+
+        Closes the last group created by `tracing.group()`.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.group_end())
+
+    async def start_har(
+        self,
+        path: typing.Union[pathlib.Path, str],
+        *,
+        content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        mode: typing.Optional[Literal["full", "minimal"]] = None,
+        url_filter: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> "AsyncContextManager":
+        """Tracing.start_har
+
+        Start recording a HAR (HTTP Archive) of network activity in this context. The HAR file is written to disk when
+        `tracing.stop_har()` is called, or when the returned `Disposable` is disposed.
+
+        Only one HAR recording can be active at a time per `BrowserContext`.
+
+        **Usage**
+
+        ```py
+        await context.tracing.start_har(\"trace.har\")
+        page = await context.new_page()
+        await page.goto(\"https://playwright.dev\")
+        await context.tracing.stop_har()
+        ```
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str]
+            Path on the filesystem to write the HAR file to. If the file name ends with `.zip`, the HAR is saved as a zip
+            archive with response bodies attached as separate files.
+        content : Union["attach", "embed", "omit", None]
+            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.
+        mode : Union["full", "minimal", None]
+            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`.
+        url_filter : Union[Pattern[str], str, None]
+            A glob or regex pattern to filter requests that are stored in the HAR. Defaults to none.
+
+        Returns
+        -------
+        AsyncContextManager
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.start_har(
+                path=path, content=content, mode=mode, urlFilter=url_filter
+            )
+        )
+
+    async def stop_har(self) -> None:
+        """Tracing.stop_har
+
+        Stop HAR recording and save the HAR file to the path given to `tracing.start_har()`.
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.stop_har())
+
+
+mapping.register(TracingImpl, Tracing)
+
+
+class Locator(AsyncBase):
+
+    @property
+    def page(self) -> "Page":
+        """Locator.page
+
+        A page this locator belongs to.
+
+        Returns
+        -------
+        Page
+        """
+        return mapping.from_impl(self._impl_obj.page)
+
+    @property
+    def first(self) -> "Locator":
+        """Locator.first
+
+        Returns locator to the first matching element.
+
+        Returns
+        -------
+        Locator
+        """
+        return mapping.from_impl(self._impl_obj.first)
+
+    @property
+    def last(self) -> "Locator":
+        """Locator.last
+
+        Returns locator to the last matching element.
+
+        **Usage**
+
+        ```py
+        banana = await page.get_by_role(\"listitem\").last
+        ```
+
+        Returns
+        -------
+        Locator
+        """
+        return mapping.from_impl(self._impl_obj.last)
+
+    @property
+    def content_frame(self) -> "FrameLocator":
+        """Locator.content_frame
+
+        Returns a `FrameLocator` object pointing to the same `iframe` as this locator.
+
+        Useful when you have a `Locator` object obtained somewhere, and later on would like to interact with the content
+        inside the frame.
+
+        For a reverse operation, use `frame_locator.owner()`.
+
+        **Usage**
+
+        ```py
+        locator = page.locator(\"iframe[name=\\\"embedded\\\"]\")
+        # ...
+        frame_locator = locator.content_frame
+        await frame_locator.get_by_role(\"button\").click()
+        ```
+
+        Returns
+        -------
+        FrameLocator
+        """
+        return mapping.from_impl(self._impl_obj.content_frame)
+
+    @property
+    def description(self) -> typing.Optional[str]:
+        """Locator.description
+
+        Returns locator description previously set with `locator.describe()`. Returns `null` if no custom
+        description has been set.
+
+        **Usage**
+
+        ```py
+        button = page.get_by_role(\"button\").describe(\"Subscribe button\")
+        print(button.description())  # \"Subscribe button\"
+
+        input = page.get_by_role(\"textbox\")
+        print(input.description())  # None
+        ```
+
+        Returns
+        -------
+        Union[str, None]
+        """
+        return mapping.from_maybe_impl(self._impl_obj.description)
+
+    async def bounding_box(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[FloatRect]:
+        """Locator.bounding_box
+
+        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**
+
+        ```py
+        box = await page.get_by_role(\"button\").bounding_box()
+        await page.mouse.click(box[\"x\"] + box[\"width\"] / 2, box[\"y\"] + box[\"height\"] / 2)
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        Union[{x: float, y: float, width: float, height: float}, None]
+        """
+
+        return mapping.from_impl_nullable(
+            await self._impl_obj.bounding_box(timeout=to_milliseconds(timeout))
+        )
+
+    async def check(
+        self,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.check
+
+        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/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **Usage**
+
+        ```py
+        await page.get_by_role(\"checkbox\").check()
+        ```
+
+        Parameters
+        ----------
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.check(
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+            )
+        )
+
+    async def click(
+        self,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
+        """Locator.click
+
+        Click an element.
+
+        **Details**
+
+        This method clicks the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to click in the center of the element, or the specified `position`.
+        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **Usage**
+
+        Click a button:
+
+        ```py
+        await page.get_by_role(\"button\").click()
+        ```
+
+        Shift-right-click at a specific position on a canvas:
+
+        ```py
+        await page.locator(\"canvas\").click(
+            button=\"right\", modifiers=[\"Shift\"], position={\"x\": 23, \"y\": 32}
+        )
+        ```
+
+        Parameters
+        ----------
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
+            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
+        button : Union["left", "middle", "right", None]
+            Defaults to `left`.
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.click(
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                delay=delay,
+                button=button,
+                clickCount=click_count,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+                steps=steps,
+            )
+        )
+
+    async def dblclick(
+        self,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
+        """Locator.dblclick
+
+        Double-click an element.
+
+        **Details**
+
+        This method double clicks the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to double click in the center of the element, or the specified `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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **NOTE** `element.dblclick()` dispatches two `click` events and a single `dblclick` event.
+
+        Parameters
+        ----------
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
+            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
+        button : Union["left", "middle", "right", None]
+            Defaults to `left`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.dblclick(
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                delay=delay,
+                button=button,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+                steps=steps,
+            )
+        )
+
+    async def dispatch_event(
+        self,
+        type: str,
+        event_init: typing.Optional[typing.Dict] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.dispatch_event
+
+        Programmatically dispatch an event on the matching element.
+
+        **Usage**
+
+        ```py
+        await locator.dispatch_event(\"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`, initializes it with `eventInit`
+        properties and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
+
+        Since `eventInit` 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:
+
+        ```py
+        data_transfer = await page.evaluate_handle(\"new DataTransfer()\")
+        await locator.dispatch_event(\"#source\", \"dragstart\", {\"dataTransfer\": data_transfer})
+        ```
+
+        Parameters
+        ----------
+        type : str
+            DOM event type: `"click"`, `"dragstart"`, etc.
+        event_init : Union[Dict, None]
+            Optional event-specific initialization properties.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.dispatch_event(
+                type=type,
+                eventInit=mapping.to_impl(event_init),
+                timeout=to_milliseconds(timeout),
+            )
+        )
+
+    async def evaluate(
+        self,
+        expression: str,
+        arg: typing.Optional[typing.Any] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Any:
+        """Locator.evaluate
+
+        Execute JavaScript code in the page, taking the matching element as an argument.
+
+        **Details**
+
+        Returns the return value of `expression`, called with the matching element as a first argument, and `arg` as a
+        second argument.
+
+        If `expression` returns a [Promise], this method will wait for the promise to resolve and return its value.
+
+        If `expression` throws or rejects, this method throws.
+
+        **Usage**
+
+        Passing argument to `expression`:
+
+        ```py
+        result = await page.get_by_testid(\"myId\").evaluate(\"(element, [x, y]) => element.textContent + ' ' + x * y\", [7, 8])
+        print(result) # prints \"myId text 56\"
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the locator before evaluating. Note that after locator is resolved,
+            evaluation itself is not limited by the timeout. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.evaluate(
+                expression=expression,
+                arg=mapping.to_impl(arg),
+                timeout=to_milliseconds(timeout),
+            )
+        )
+
+    async def evaluate_all(
+        self, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> typing.Any:
+        """Locator.evaluate_all
+
+        Execute JavaScript code in the page, taking all matching elements as an argument.
+
+        **Details**
+
+        Returns the return value of `expression`, called with an array of all matching elements as a first argument, and
+        `arg` as a second argument.
+
+        If `expression` returns a [Promise], this method will wait for the promise to resolve and return its value.
+
+        If `expression` throws or rejects, this method throws.
+
+        **Usage**
+
+        ```py
+        locator = page.locator(\"div\")
+        more_than_ten = await locator.evaluate_all(\"(divs, min) => divs.length > min\", 10)
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.evaluate_all(
+                expression=expression, arg=mapping.to_impl(arg)
+            )
+        )
+
+    async def evaluate_handle(
+        self,
+        expression: str,
+        arg: typing.Optional[typing.Any] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> "JSHandle":
+        """Locator.evaluate_handle
+
+        Execute JavaScript code in the page, taking the matching element as an argument, and return a `JSHandle` with the
+        result.
+
+        **Details**
+
+        Returns the return value of `expression` as a`JSHandle`, called with the matching element as a first argument, and
+        `arg` as a second argument.
+
+        The only difference between `locator.evaluate()` and `locator.evaluate_handle()` is that
+        `locator.evaluate_handle()` returns `JSHandle`.
+
+        If `expression` returns a [Promise], this method will wait for the promise to resolve and return its value.
+
+        If `expression` throws or rejects, this method throws.
+
+        See `page.evaluate_handle()` for more details.
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the locator before evaluating. Note that after locator is resolved,
+            evaluation itself is not limited by the timeout. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+
+        Returns
+        -------
+        JSHandle
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.evaluate_handle(
+                expression=expression,
+                arg=mapping.to_impl(arg),
+                timeout=to_milliseconds(timeout),
+            )
+        )
+
+    async def fill(
+        self,
+        value: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.fill
+
+        Set a value to the input field.
+
+        **Usage**
+
+        ```py
+        await page.get_by_role(\"textbox\").fill(\"example value\")
+        ```
+
+        **Details**
+
+        This method waits for [actionability](https://playwright.dev/python/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.press_sequentially()`.
+
+        Parameters
+        ----------
+        value : str
+            Value to set for the `<input>`, `<textarea>` or `[contenteditable]` element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.fill(
+                value=value,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                force=force,
+            )
+        )
+
+    async def clear(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.clear
+
+        Clear the input field.
+
+        **Details**
+
+        This method waits for [actionability](https://playwright.dev/python/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**
+
+        ```py
+        await page.get_by_role(\"textbox\").clear()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.clear(
+                timeout=to_milliseconds(timeout), noWaitAfter=no_wait_after, force=force
+            )
+        )
+
+    def locator(
+        self,
+        selector_or_locator: typing.Union[str, "Locator"],
+        *,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has: typing.Optional["Locator"] = None,
+        has_not: typing.Optional["Locator"] = None,
+    ) -> "Locator":
+        """Locator.locator
+
+        The method finds an element matching the specified selector in the locator's subtree. It also accepts filter
+        options, similar to `locator.filter()` method.
+
+        [Learn more about locators](https://playwright.dev/python/docs/locators).
+
+        Parameters
+        ----------
+        selector_or_locator : Union[Locator, str]
+            A selector or locator to use when resolving DOM element.
+        has_text : Union[Pattern[str], str, None]
+            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>`.
+        has_not_text : Union[Pattern[str], str, None]
+            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.
+        has : Union[Locator, None]
+            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`s.
+        has_not : Union[Locator, None]
+            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`s.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.locator(
+                selectorOrLocator=selector_or_locator,
+                hasText=has_text,
+                hasNotText=has_not_text,
+                has=has._impl_obj if has else None,
+                hasNot=has_not._impl_obj if has_not else None,
+            )
+        )
+
+    def get_by_alt_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.get_by_alt_text
+
+        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'>
+        ```
+
+        ```py
+        await page.get_by_alt_text(\"Playwright logo\").click()
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_alt_text(text=text, exact=exact))
+
+    def get_by_label(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.get_by_label
+
+        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\">
+        ```
+
+        ```py
+        await page.get_by_label(\"Username\").fill(\"john\")
+        await page.get_by_label(\"Password\").fill(\"secret\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_label(text=text, exact=exact))
+
+    def get_by_placeholder(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.get_by_placeholder
+
+        Allows locating input elements by the placeholder text.
+
+        **Usage**
+
+        For example, consider the following DOM structure.
+
+        ```html
+        <input type=\"email\" placeholder=\"name@example.com\" />
+        ```
+
+        You can fill the input after locating it by the placeholder text:
+
+        ```py
+        await page.get_by_placeholder(\"name@example.com\").fill(\"playwright@microsoft.com\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_placeholder(text=text, exact=exact)
+        )
+
+    def get_by_role(
+        self,
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
+        ],
+        *,
+        checked: typing.Optional[bool] = None,
+        disabled: typing.Optional[bool] = None,
+        expanded: typing.Optional[bool] = None,
+        include_hidden: typing.Optional[bool] = None,
+        level: typing.Optional[int] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        pressed: typing.Optional[bool] = None,
+        selected: typing.Optional[bool] = None,
+        exact: typing.Optional[bool] = None,
+        description: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> "Locator":
+        """Locator.get_by_role
+
+        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 its implicit role:
+
+        ```py
+        await expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
+
+        await page.get_by_role(\"checkbox\", name=\"Subscribe\").check()
+
+        await page.get_by_role(\"button\", name=re.compile(\"submit\", re.IGNORECASE)).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.
+
+        Parameters
+        ----------
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        checked : Union[bool, None]
+            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).
+        disabled : Union[bool, None]
+            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).
+
+        expanded : Union[bool, None]
+            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).
+        include_hidden : Union[bool, None]
+            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).
+        level : Union[int, None]
+            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).
+        name : Union[Pattern[str], str, None]
+            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` to control this behavior.
+
+            Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
+        pressed : Union[bool, None]
+            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).
+        selected : Union[bool, None]
+            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).
+        exact : Union[bool, None]
+            Whether `name` and `description` are matched exactly: case-sensitive and whole-string. Defaults to false. Ignored
+            when the value is a regular expression. Note that exact match still trims whitespace.
+        description : Union[Pattern[str], str, None]
+            Option to match the [accessible description](https://w3c.github.io/accname/#dfn-accessible-description). By
+            default, matching is case-insensitive and searches for a substring, use `exact` to control this behavior.
+
+            Learn more about [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_role(
+                role=role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=include_hidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
+
+    def get_by_test_id(
+        self, test_id: typing.Union[str, typing.Pattern[str]]
+    ) -> "Locator":
+        """Locator.get_by_test_id
+
+        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 its test id:
+
+        ```py
+        await page.get_by_test_id(\"directions\").click()
+        ```
+
+        **Details**
+
+        By default, the `data-testid` attribute is used as a test id. Use `selectors.set_test_id_attribute()` to
+        configure a different test id attribute if necessary.
+
+        Parameters
+        ----------
+        test_id : Union[Pattern[str], str]
+            Id to locate the element by.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_test_id(testId=test_id))
+
+    def get_by_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.get_by_text
+
+        Allows locating elements that contain given text.
+
+        See also `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:
+
+        ```py
+        # Matches <span>
+        page.get_by_text(\"world\")
+
+        # Matches first <div>
+        page.get_by_text(\"Hello world\")
+
+        # Matches second <div>
+        page.get_by_text(\"Hello\", exact=True)
+
+        # Matches both <div>s
+        page.get_by_text(re.compile(\"Hello\"))
+
+        # Matches second <div>
+        page.get_by_text(re.compile(\"^hello$\", re.IGNORECASE))
+        ```
+
+        **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\">`.
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_text(text=text, exact=exact))
+
+    def get_by_title(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.get_by_title
+
+        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:
+
+        ```py
+        await expect(page.get_by_title(\"Issues count\")).to_have_text(\"25 issues\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_title(text=text, exact=exact))
+
+    def frame_locator(self, selector: str) -> "FrameLocator":
+        """Locator.frame_locator
+
+        When working with iframes, you can create a frame locator that will enter the iframe and allow locating elements in
+        that iframe:
+
+        **Usage**
+
+        ```py
+        locator = page.frame_locator(\"iframe\").get_by_text(\"Submit\")
+        await locator.click()
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to use when resolving DOM element.
+
+        Returns
+        -------
+        FrameLocator
+        """
+
+        return mapping.from_impl(self._impl_obj.frame_locator(selector=selector))
+
+    async def element_handle(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> "ElementHandle":
+        """Locator.element_handle
+
+        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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        ElementHandle
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.element_handle(timeout=to_milliseconds(timeout))
+        )
+
+    async def element_handles(self) -> typing.List["ElementHandle"]:
+        """Locator.element_handles
+
+        Resolves given locator to all matching DOM elements. If there are no matching elements, returns an empty list.
+
+        Returns
+        -------
+        List[ElementHandle]
+        """
+
+        return mapping.from_impl_list(await self._impl_obj.element_handles())
+
+    def nth(self, index: int) -> "Locator":
+        """Locator.nth
+
+        Returns locator to the n-th matching element. It's zero based, `nth(0)` selects the first element.
+
+        **Usage**
+
+        ```py
+        banana = await page.get_by_role(\"listitem\").nth(2)
+        ```
+
+        Parameters
+        ----------
+        index : int
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.nth(index=index))
+
+    def describe(self, description: str) -> "Locator":
+        """Locator.describe
+
+        Describes the locator, description is used in the trace viewer and reports. Returns the locator pointing to the
+        same element.
+
+        **Usage**
+
+        ```py
+        button = page.get_by_test_id(\"btn-sub\").describe(\"Subscribe button\")
+        await button.click()
+        ```
+
+        Parameters
+        ----------
+        description : str
+            Locator description.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.describe(description=description))
+
+    def filter(
+        self,
+        *,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has: typing.Optional["Locator"] = None,
+        has_not: typing.Optional["Locator"] = None,
+        visible: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.filter
+
+        This method narrows existing locator according to the options, for example filters by text. It can be chained to
+        filter multiple times.
+
+        **Usage**
+
+        ```py
+        row_locator = page.locator(\"tr\")
+        # ...
+        await row_locator.filter(has_text=\"text in column 1\").filter(
+            has=page.get_by_role(\"button\", name=\"column 2 button\")
+        ).screenshot()
+
+        ```
+
+        Parameters
+        ----------
+        has_text : Union[Pattern[str], str, None]
+            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>`.
+        has_not_text : Union[Pattern[str], str, None]
+            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.
+        has : Union[Locator, None]
+            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`s.
+        has_not : Union[Locator, None]
+            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`s.
+        visible : Union[bool, None]
+            Only matches visible or invisible elements.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.filter(
+                hasText=has_text,
+                hasNotText=has_not_text,
+                has=has._impl_obj if has else None,
+                hasNot=has_not._impl_obj if has_not else None,
+                visible=visible,
+            )
+        )
+
+    def or_(self, locator: "Locator") -> "Locator":
+        """Locator.or_
+
+        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/python/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/python/docs/locators#strictness). In this case, you can use
+        `locator.first()` to only match one of them.
+
+        ```py
+        new_email = page.get_by_role(\"button\", name=\"New\")
+        dialog = page.get_by_text(\"Confirm security settings\")
+        await expect(new_email.or_(dialog).first).to_be_visible()
+        if (await dialog.is_visible()):
+          await page.get_by_role(\"button\", name=\"Dismiss\").click()
+        await new_email.click()
+        ```
+
+        Parameters
+        ----------
+        locator : Locator
+            Alternative locator to match.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.or_(locator=locator._impl_obj))
+
+    def and_(self, locator: "Locator") -> "Locator":
+        """Locator.and_
+
+        Creates a locator that matches both this locator and the argument locator.
+
+        **Usage**
+
+        The following example finds a button with a specific title.
+
+        ```py
+        button = page.get_by_role(\"button\").and_(page.get_by_title(\"Subscribe\"))
+        ```
+
+        Parameters
+        ----------
+        locator : Locator
+            Additional locator to match.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.and_(locator=locator._impl_obj))
+
+    async def focus(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.focus
+
+        Calls [focus](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the matching element.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.focus(timeout=to_milliseconds(timeout))
+        )
+
+    async def blur(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.blur
+
+        Calls [blur](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/blur) on the element.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.blur(timeout=to_milliseconds(timeout))
+        )
+
+    async def all(self) -> typing.List["Locator"]:
+        """Locator.all
+
+        When the locator points to a list of elements, this returns an array of locators, pointing to their respective
+        elements.
+
+        **NOTE** `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()` 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()`.
+
+        **Usage**
+
+        ```py
+        for li in await page.get_by_role('listitem').all():
+          await li.click();
+        ```
+
+        Returns
+        -------
+        List[Locator]
+        """
+
+        return mapping.from_impl_list(await self._impl_obj.all())
+
+    async def count(self) -> int:
+        """Locator.count
+
+        Returns the number of elements matching the locator.
+
+        **NOTE** If you need to assert the number of elements on the page, prefer `locator_assertions.to_have_count()`
+        to avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        count = await page.get_by_role(\"listitem\").count()
+        ```
+
+        Returns
+        -------
+        int
+        """
+
+        return mapping.from_maybe_impl(await self._impl_obj.count())
+
+    async def drag_to(
+        self,
+        target: "Locator",
+        *,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        trial: typing.Optional[bool] = None,
+        source_position: typing.Optional[Position] = None,
+        target_position: typing.Optional[Position] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
+        """Locator.drag_to
+
+        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**
+
+        ```py
+        source = page.locator(\"#source\")
+        target = page.locator(\"#target\")
+
+        await source.drag_to(target)
+        # or specify exact positions relative to the top-left corners of the elements:
+        await source.drag_to(
+          target,
+          source_position={\"x\": 34, \"y\": 7},
+          target_position={\"x\": 10, \"y\": 20}
+        )
+        ```
+
+        Parameters
+        ----------
+        target : Locator
+            Locator of the element to drag to.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        source_position : Union[{x: float, y: float}, None]
+            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.
+        target_position : Union[{x: float, y: float}, None]
+            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.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.drag_to(
+                target=target._impl_obj,
+                force=force,
+                noWaitAfter=no_wait_after,
+                timeout=to_milliseconds(timeout),
+                trial=trial,
+                sourcePosition=source_position,
+                targetPosition=target_position,
+                steps=steps,
+            )
+        )
+
+    async def drop(
+        self,
+        payload: DropPayload,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.drop
+
+        Simulate an external drag-and-drop of files or clipboard-like data onto this locator.
+
+        **Details**
+
+        Dispatches the native `dragenter`, `dragover`, and `drop` events at the center of the target element with a
+        synthetic [DataTransfer] carrying the provided files and/or data entries. Works cross-browser by constructing the
+        [DataTransfer] in the page context.
+
+        If the target element's `dragover` listener does not call `preventDefault()`, the target is considered to have
+        rejected the drop: Playwright dispatches `dragleave` and this method throws.
+
+        **Usage**
+
+        Drop a file buffer onto an upload area:
+
+        Drop plain text and a URL together:
+
+        Parameters
+        ----------
+        payload : {files: Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}, None], data: Union[Dict[str, str], None]}
+            Data to drop onto the target. Provide `files` (file paths or in-memory buffers), `data` (a mime-type → string map
+            for clipboard-like content such as `text/plain`, `text/html`, `text/uri-list`), or both.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.drop(
+                payload=payload, position=position, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def get_attribute(
+        self,
+        name: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Locator.get_attribute
+
+        Returns the matching element's attribute value.
+
+        **NOTE** If you need to assert an element's attribute, prefer `locator_assertions.to_have_attribute()` to
+        avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        Parameters
+        ----------
+        name : str
+            Attribute name to get the value for.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.get_attribute(
+                name=name, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def hover(
+        self,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.hover
+
+        Hover over the matching element.
+
+        **Usage**
+
+        ```py
+        await page.get_by_role(\"link\").hover()
+        ```
+
+        **Details**
+
+        This method hovers over the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to hover over the center of the element, or the specified `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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.hover(
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                force=force,
+                trial=trial,
+            )
+        )
+
+    async def inner_html(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Locator.inner_html
+
+        Returns the [`element.innerHTML`](https://developer.mozilla.org/en-US/docs/Web/API/Element/innerHTML).
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.inner_html(timeout=to_milliseconds(timeout))
+        )
+
+    async def inner_text(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Locator.inner_text
+
+        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 `locator_assertions.to_have_text()` with
+        `useInnerText` option to avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.inner_text(timeout=to_milliseconds(timeout))
+        )
+
+    async def input_value(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Locator.input_value
+
+        Returns the value for the matching `<input>` or `<textarea>` or `<select>` element.
+
+        **NOTE** If you need to assert input value, prefer `locator_assertions.to_have_value()` to avoid flakiness.
+        See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        value = await page.get_by_role(\"textbox\").input_value()
+        ```
+
+        **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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.input_value(timeout=to_milliseconds(timeout))
+        )
+
+    async def is_checked(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_checked
+
+        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 `locator_assertions.to_be_checked()` to avoid
+        flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        checked = await page.get_by_role(\"checkbox\").is_checked()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_checked(timeout=to_milliseconds(timeout))
+        )
+
+    async def is_disabled(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_disabled
+
+        Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability#enabled).
+
+        **NOTE** If you need to assert that an element is disabled, prefer `locator_assertions.to_be_disabled()` to
+        avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        disabled = await page.get_by_role(\"button\").is_disabled()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_disabled(timeout=to_milliseconds(timeout))
+        )
+
+    async def is_editable(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_editable
+
+        Returns whether the element is [editable](https://playwright.dev/python/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 `locator_assertions.to_be_editable()` to
+        avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        editable = await page.get_by_role(\"textbox\").is_editable()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_editable(timeout=to_milliseconds(timeout))
+        )
+
+    async def is_enabled(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_enabled
+
+        Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
+
+        **NOTE** If you need to assert that an element is enabled, prefer `locator_assertions.to_be_enabled()` to
+        avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        enabled = await page.get_by_role(\"button\").is_enabled()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_enabled(timeout=to_milliseconds(timeout))
+        )
+
+    async def is_hidden(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_hidden
+
+        Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability#visible).
+
+        **NOTE** If you need to assert that element is hidden, prefer `locator_assertions.to_be_hidden()` to avoid
+        flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        hidden = await page.get_by_role(\"button\").is_hidden()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Deprecated: This option is ignored. `locator.is_hidden()` does not wait for the element to become hidden and returns immediately.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_hidden(timeout=to_milliseconds(timeout))
+        )
+
+    async def is_visible(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_visible
+
+        Returns whether the element is [visible](https://playwright.dev/python/docs/actionability#visible).
+
+        **NOTE** If you need to assert that element is visible, prefer `locator_assertions.to_be_visible()` to avoid
+        flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        visible = await page.get_by_role(\"button\").is_visible()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Deprecated: This option is ignored. `locator.is_visible()` does not wait for the element to become visible and returns immediately.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.is_visible(timeout=to_milliseconds(timeout))
+        )
+
+    async def press(
+        self,
+        key: str,
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.press
+
+        Focuses the matching element and presses a combination of the keys.
+
+        **Usage**
+
+        ```py
+        await page.get_by_role(\"textbox\").press(\"Backspace\")
+        ```
+
+        **Details**
+
+        Focuses the element, and then uses `keyboard.down()` and `keyboard.up()`.
+
+        `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` 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` in the upper case.
+
+        If `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.
+
+        Parameters
+        ----------
+        key : str
+            Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
+        delay : Union[float, None]
+            Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.press(
+                key=key,
+                delay=delay,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+            )
+        )
+
+    async def screenshot(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        type: typing.Optional[Literal["jpeg", "png"]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+        omit_background: typing.Optional[bool] = None,
+        animations: typing.Optional[Literal["allow", "disabled"]] = None,
+        caret: typing.Optional[Literal["hide", "initial"]] = None,
+        scale: typing.Optional[Literal["css", "device"]] = None,
+        mask: typing.Optional[typing.Sequence["Locator"]] = None,
+        mask_color: typing.Optional[str] = None,
+        style: typing.Optional[str] = None,
+    ) -> bytes:
+        """Locator.screenshot
+
+        Take a screenshot of the element matching the locator.
+
+        **Usage**
+
+        ```py
+        await page.get_by_role(\"link\").screenshot()
+        ```
+
+        Disable animations and save screenshot to a file:
+
+        ```py
+        await page.get_by_role(\"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/python/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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        type : Union["jpeg", "png", None]
+            Specify screenshot type, defaults to `png`.
+        path : Union[pathlib.Path, str, None]
+            The file path to save the image to. The screenshot type will be inferred from file extension. If `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.
+        quality : Union[int, None]
+            The quality of the image, between 0-100. Not applicable to `png` images.
+        omit_background : Union[bool, None]
+            Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.
+            Defaults to `false`.
+        animations : Union["allow", "disabled", None]
+            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.
+        caret : Union["hide", "initial", None]
+            When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be
+            changed.  Defaults to `"hide"`.
+        scale : Union["css", "device", None]
+            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"`.
+        mask : Union[Sequence[Locator], None]
+            Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
+        mask_color : Union[str, None]
+            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`.
+        style : Union[str, None]
+            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.
+
+        Returns
+        -------
+        bytes
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.screenshot(
+                timeout=to_milliseconds(timeout),
+                type=type,
+                path=path,
+                quality=quality,
+                omitBackground=omit_background,
+                animations=animations,
+                caret=caret,
+                scale=scale,
+                mask=mapping.to_impl(mask),
+                maskColor=mask_color,
+                style=style,
+            )
+        )
+
+    async def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        depth: typing.Optional[int] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = None,
+        boxes: typing.Optional[bool] = None,
+    ) -> str:
+        """Locator.aria_snapshot
+
+        Captures the aria snapshot of the given element. Read more about [aria snapshots](https://playwright.dev/python/docs/aria-snapshots) and
+        `locator_assertions.to_match_aria_snapshot()` for the corresponding assertion.
+
+        **Usage**
+
+        ```py
+        await page.get_by_role(\"link\").aria_snapshot()
+        ```
+
+        **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\"
+        ```
+
+        An AI-optimized snapshot, controlled by `mode`, is different from a default snapshot:
+        1. Includes element references `[ref=e2]`. 2. Does not wait for an element matching the locator, and throws when
+           no elements match. 3. Includes snapshots of `<iframe>`s inside the target.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
+        mode : Union["ai", "default", None]
+            When set to `"ai"`, returns a snapshot optimized for AI consumption. Defaults to `"default"`. See details for more
+            information.
+        boxes : Union[bool, None]
+            When `true`, appends each element's bounding box as `[box=x,y,width,height]` to the snapshot. Coordinates are
+            relative to the viewport, in CSS pixels, as returned by
+            [`Element.getBoundingClientRect()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
+            Defaults to `false`.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.aria_snapshot(
+                timeout=to_milliseconds(timeout), depth=depth, mode=mode, boxes=boxes
+            )
+        )
+
+    async def normalize(self) -> "Locator":
+        """Locator.normalize
+
+        Returns a new locator that uses best practices for referencing the matched element, prioritizing test ids, aria
+        roles, and other user-facing attributes over CSS selectors. This is useful for converting implementation-detail
+        selectors into more resilient, human-readable locators.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(await self._impl_obj.normalize())
+
+    async def scroll_into_view_if_needed(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.scroll_into_view_if_needed
+
+        This method waits for [actionability](https://playwright.dev/python/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/python/docs/input#scrolling) for alternative ways to scroll.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.scroll_into_view_if_needed(
+                timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def select_option(
+        self,
+        value: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        *,
+        index: typing.Optional[typing.Union[int, typing.Sequence[int]]] = None,
+        label: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        element: typing.Optional[
+            typing.Union["ElementHandle", typing.Sequence["ElementHandle"]]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> typing.List[str]:
+        """Locator.select_option
+
+        Selects option or options in `<select>`.
+
+        **Details**
+
+        This method waits for [actionability](https://playwright.dev/python/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</option>
+          <option value=\"green\">Green</option>
+          <option value=\"blue\">Blue</option>
+        </select>
+        ```
+
+        ```py
+        # single selection matching the value or label
+        await element.select_option(\"blue\")
+        # single selection matching the label
+        await element.select_option(label=\"blue\")
+        # multiple selection for blue, red and second option
+        await element.select_option(value=[\"red\", \"green\", \"blue\"])
+        ```
+
+        Parameters
+        ----------
+        value : Union[Sequence[str], str, None]
+            Options to select by value. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        index : Union[Sequence[int], int, None]
+            Options to select by index. Optional.
+        label : Union[Sequence[str], str, None]
+            Options to select by label. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        element : Union[ElementHandle, Sequence[ElementHandle], None]
+            Option elements to select. Optional.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+
+        Returns
+        -------
+        List[str]
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.select_option(
+                value=mapping.to_impl(value),
+                index=mapping.to_impl(index),
+                label=mapping.to_impl(label),
+                element=mapping.to_impl(element),
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+                force=force,
+            )
+        )
+
+    async def select_text(
+        self,
+        *,
+        force: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.select_text
+
+        This method waits for [actionability](https://playwright.dev/python/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.
+
+        Parameters
+        ----------
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.select_text(
+                force=force, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def set_input_files(
+        self,
+        files: typing.Union[
+            str,
+            pathlib.Path,
+            FilePayload,
+            typing.Sequence[typing.Union[str, pathlib.Path]],
+            typing.Sequence[FilePayload],
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.set_input_files
+
+        Upload file or multiple files into `<input type=file>`. For inputs with a `[webkitdirectory]` attribute, only a
+        single directory path is supported.
+
+        **Usage**
+
+        ```py
+        # Select one file
+        await page.get_by_label(\"Upload file\").set_input_files('myfile.pdf')
+
+        # Select multiple files
+        await page.get_by_label(\"Upload files\").set_input_files(['file1.txt', 'file2.txt'])
+
+        # Select a directory
+        await page.get_by_label(\"Upload directory\").set_input_files('mydir')
+
+        # Remove all the selected files
+        await page.get_by_label(\"Upload file\").set_input_files([])
+
+        # Upload buffer from memory
+        await page.get_by_label(\"Upload file\").set_input_files(
+            files=[
+                {\"name\": \"test.txt\", \"mimeType\": \"text/plain\", \"buffer\": b\"this is a 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` 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.
+
+        Parameters
+        ----------
+        files : Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}]
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_input_files(
+                files=mapping.to_impl(files),
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+            )
+        )
+
+    async def tap(
+        self,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.tap
+
+        Perform a tap gesture on the element matching the locator. For examples of emulating other gestures by manually
+        dispatching touch events, see the [emulating legacy touch events](https://playwright.dev/python/docs/touch-events) page.
+
+        **Details**
+
+        This method taps the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.touchscreen` to tap the center of the element, or the specified `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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **NOTE** `element.tap()` requires that the `hasTouch` option of the browser context be set to true.
+
+        Parameters
+        ----------
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.tap(
+                modifiers=mapping.to_impl(modifiers),
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+            )
+        )
+
+    async def text_content(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Locator.text_content
+
+        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 `locator_assertions.to_have_text()` to avoid
+        flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.text_content(timeout=to_milliseconds(timeout))
+        )
+
+    async def type(
+        self,
+        text: str,
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.type
+
+        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()`.
+
+        **Usage**
+
+        Parameters
+        ----------
+        text : str
+            A text to type into a focused element.
+        delay : Union[float, None]
+            Time to wait between key presses in milliseconds. Defaults to 0.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.type(
+                text=text,
+                delay=delay,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+            )
+        )
+
+    async def press_sequentially(
+        self,
+        text: str,
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.press_sequentially
+
+        **NOTE** In most cases, you should use `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()`.
+
+        **Usage**
+
+        ```py
+        await locator.press_sequentially(\"hello\") # types instantly
+        await locator.press_sequentially(\"world\", delay=100) # types slower, like a user
+        ```
+
+        An example of typing into a text field and then submitting the form:
+
+        ```py
+        locator = page.get_by_label(\"Password\")
+        await locator.press_sequentially(\"my password\")
+        await locator.press(\"Enter\")
+        ```
+
+        Parameters
+        ----------
+        text : str
+            String of characters to sequentially press into a focused element.
+        delay : Union[float, None]
+            Time to wait between key presses in milliseconds. Defaults to 0.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.press_sequentially(
+                text=text,
+                delay=delay,
+                timeout=to_milliseconds(timeout),
+                noWaitAfter=no_wait_after,
+            )
+        )
+
+    async def uncheck(
+        self,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.uncheck
+
+        Ensure that checkbox or radio element is unchecked.
+
+        **Usage**
+
+        ```py
+        await page.get_by_role(\"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/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
         Parameters
         ----------
-        timeout : int
-            Maximum time in milliseconds
-        """
-
-        try:
-            log_api("=> page.set_default_timeout started")
-            result = mapping.from_maybe_impl(
-                self._impl_obj.setDefaultTimeout(timeout=timeout)
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.uncheck(
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
             )
-            log_api("<= page.set_default_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_default_timeout failed")
-            raise e
+        )
 
-    async def query_selector(
-        self, selector: str
-    ) -> typing.Union["ElementHandle", NoneType]:
-        """Page.query_selector
+    async def all_inner_texts(self) -> typing.List[str]:
+        """Locator.all_inner_texts
 
-        The method finds an element matching the specified selector within the page. If no elements match the selector, the
-        return value resolves to `null`.
-        Shortcut for main frame's frame.$(selector).
+        Returns an array of `node.innerText` values for all matching nodes.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
+        **NOTE** If you need to assert text on the page, prefer `locator_assertions.to_have_text()` with
+        `useInnerText` option to avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        texts = await page.get_by_role(\"link\").all_inner_texts()
+        ```
 
         Returns
         -------
-        Optional[ElementHandle]
+        List[str]
         """
 
-        try:
-            log_api("=> page.query_selector started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.querySelector(selector=selector)
-            )
-            log_api("<= page.query_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.query_selector failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.all_inner_texts())
 
-    async def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
-        """Page.query_selector_all
+    async def all_text_contents(self) -> typing.List[str]:
+        """Locator.all_text_contents
 
-        The method finds all elements matching the specified selector within the page. If no elements match the selector, the
-        return value resolves to `[]`.
-        Shortcut for main frame's frame.$$(selector).
+        Returns an array of `node.textContent` values for all matching nodes.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
+        **NOTE** If you need to assert text on the page, prefer `locator_assertions.to_have_text()` to avoid
+        flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        texts = await page.get_by_role(\"link\").all_text_contents()
+        ```
 
         Returns
         -------
-        List[ElementHandle]
+        List[str]
         """
 
-        try:
-            log_api("=> page.query_selector_all started")
-            result = mapping.from_impl_list(
-                await self._impl_obj.querySelectorAll(selector=selector)
-            )
-            log_api("<= page.query_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.query_selector_all failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.all_text_contents())
 
-    async def wait_for_selector(
+    async def wait_for(
         self,
-        selector: str,
-        timeout: int = None,
-        state: Literal["attached", "detached", "hidden", "visible"] = None,
-    ) -> typing.Union["ElementHandle", NoneType]:
-        """Page.wait_for_selector
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        state: typing.Optional[
+            Literal["attached", "detached", "hidden", "visible"]
+        ] = None,
+    ) -> None:
+        """Locator.wait_for
 
-        Returns when element specified by selector satisfies `state` option. Resolves to `null` if waiting for `hidden` or
-        `detached`.
-        Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at
-        the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the
-        selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
-        This method works across navigations:
+        Returns when element specified by locator satisfies the `state` option.
+
+        If target element already satisfies the condition, the method returns immediately. Otherwise, waits for up to
+        `timeout` milliseconds until the condition is met.
+
+        **Usage**
+
+        ```py
+        order_sent = page.locator(\"#order-sent\")
+        await order_sent.wait_for()
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        state : Optional[Literal['attached', 'detached', 'hidden', 'visible']]
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        state : Union["attached", "detached", "hidden", "visible", None]
             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.
-
-        Returns
-        -------
-        Optional[ElementHandle]
+            - `'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.
         """
 
-        try:
-            log_api("=> page.wait_for_selector started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.waitForSelector(
-                    selector=selector, timeout=timeout, state=state
-                )
-            )
-            log_api("<= page.wait_for_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_selector failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.wait_for(timeout=to_milliseconds(timeout), state=state)
+        )
 
-    async def dispatch_event(
+    async def set_checked(
         self,
-        selector: str,
-        type: str,
-        event_init: typing.Dict = None,
-        timeout: int = None,
-    ) -> NoneType:
-        """Page.dispatch_event
+        checked: bool,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.set_checked
+
+        Set the state of a checkbox or a radio element.
+
+        **Usage**
+
+        ```py
+        await page.get_by_role(\"checkbox\").set_checked(True)
+        ```
 
-        The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the elment, `click`
-        is dispatched. This is equivalend to calling
-        element.click().
-        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
-        and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
-        Since `eventInit` is event-specific, please refer to the events documentation for the lists of initial properties:
+        **Details**
 
-        DragEvent
-        FocusEvent
-        KeyboardEvent
-        MouseEvent
-        PointerEvent
-        TouchEvent
-        Event
+        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/python/docs/actionability) checks on the matched element, unless `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` to click in the center of the element.
+        1. Ensure that the element is now checked or unchecked. If not, this method throws.
 
-        You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        type : str
-            DOM event type: `"click"`, `"dragstart"`, etc.
-        event_init : Optional[Dict]
-            Optional event-specific initialization properties.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        """
-
-        try:
-            log_api("=> page.dispatch_event started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.dispatchEvent(
-                    selector=selector,
-                    type=type,
-                    eventInit=mapping.to_impl(event_init),
-                    timeout=timeout,
-                )
-            )
-            log_api("<= page.dispatch_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.dispatch_event failed")
-            raise e
+        checked : bool
+            Whether to check or uncheck the checkbox.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.set_checked(
+                checked=checked,
+                position=position,
+                timeout=to_milliseconds(timeout),
+                force=force,
+                noWaitAfter=no_wait_after,
+                trial=trial,
+            )
+        )
 
-    async def evaluate(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
-    ) -> typing.Any:
-        """Page.evaluate
+    async def highlight(self, *, style: typing.Optional[str] = None) -> None:
+        """Locator.highlight
 
-        Returns the value of the `pageFunction` invacation.
-        If the function passed to the `page.evaluate` returns a Promise, then `page.evaluate` would wait for the promise to
-        resolve and return its value.
-        If the function passed to the `page.evaluate` returns a non-Serializable value, then `page.evaluate` resolves to
-        `undefined`. DevTools Protocol also supports transferring some additional values that are not serializable by `JSON`:
-        `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
-        Passing argument to `pageFunction`:
-        A string can also be passed in instead of a function:
-        ElementHandle instances can be passed as an argument to the `page.evaluate`:
-        Shortcut for main frame's frame.evaluate(pageFunction[, arg]).
+        Highlight the corresponding element(s) on the screen. Useful for debugging, don't commit the code that uses
+        `locator.highlight()`.
 
         Parameters
         ----------
-        expression : str
-            Function to be evaluated in the page context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
-
-        Returns
-        -------
-        Any
+        style : Union[str, None]
+            Additional inline CSS applied to the highlight overlay, e.g. `"outline: 2px dashed red"`.
         """
 
-        try:
-            log_api("=> page.evaluate started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.evaluate(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= page.evaluate succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.evaluate failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.highlight(style=style))
 
-    async def evaluate_handle(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
-    ) -> "JSHandle":
-        """Page.evaluate_handle
+    async def hide_highlight(self) -> None:
+        """Locator.hide_highlight
 
-        Returns the value of the `pageFunction` invacation as in-page object (JSHandle).
-        The only difference between `page.evaluate` and `page.evaluate_handle` is that `page.evaluate_handle` returns in-page
-        object (JSHandle).
-        If the function passed to the `page.evaluate_handle` returns a Promise, then `page.evaluate_handle` would wait for the
-        promise to resolve and return its value.
-        A string can also be passed in instead of a function:
-        JSHandle instances can be passed as an argument to the `page.evaluate_handle`:
+        Hides the element highlight previously added by `locator.highlight()`.
+        """
 
-        Parameters
-        ----------
-        expression : str
-            Function to be evaluated in the page context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+        return mapping.from_maybe_impl(await self._impl_obj.hide_highlight())
 
-        Returns
-        -------
-        JSHandle
-        """
 
-        try:
-            log_api("=> page.evaluate_handle started")
-            result = mapping.from_impl(
-                await self._impl_obj.evaluateHandle(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= page.evaluate_handle succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.evaluate_handle failed")
-            raise e
+mapping.register(LocatorImpl, Locator)
 
-    async def eval_on_selector(
-        self,
-        selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-    ) -> typing.Any:
-        """Page.eval_on_selector
 
-        The method finds an element matching the specified selector within the page and passes it as a first argument to
-        `pageFunction`. If no elements match the selector, the method throws an error. Returns the value of `pageFunction`.
-        If `pageFunction` returns a Promise, then `page.$eval` would wait for the promise to resolve and return its value.
-        Examples:
-        Shortcut for main frame's frame.$eval(selector, pageFunction[, arg]).
+class APIResponse(AsyncBase):
 
-        Parameters
-        ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+    @property
+    def ok(self) -> bool:
+        """APIResponse.ok
+
+        Contains a boolean stating whether the response was successful (status in the range 200-299) or not.
 
         Returns
         -------
-        Any
+        bool
         """
+        return mapping.from_maybe_impl(self._impl_obj.ok)
 
-        try:
-            log_api("=> page.eval_on_selector started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.evalOnSelector(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= page.eval_on_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.eval_on_selector failed")
-            raise e
-
-    async def eval_on_selector_all(
-        self,
-        selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-    ) -> typing.Any:
-        """Page.eval_on_selector_all
-
-        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`. Returns the result of `pageFunction` invocation.
-        If `pageFunction` returns a Promise, then `page.$$eval` would wait for the promise to resolve and return its value.
-        Examples:
+    @property
+    def url(self) -> str:
+        """APIResponse.url
 
-        Parameters
-        ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+        Contains the URL of the response.
 
         Returns
         -------
-        Any
+        str
         """
+        return mapping.from_maybe_impl(self._impl_obj.url)
 
-        try:
-            log_api("=> page.eval_on_selector_all started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.evalOnSelectorAll(
-                    selector=selector,
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                )
-            )
-            log_api("<= page.eval_on_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.eval_on_selector_all failed")
-            raise e
-
-    async def add_script_tag(
-        self,
-        url: str = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content: str = None,
-        type: str = None,
-    ) -> "ElementHandle":
-        """Page.add_script_tag
-
-        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.
-        Shortcut for main frame's frame.add_script_tag(script).
+    @property
+    def status(self) -> int:
+        """APIResponse.status
 
-        Parameters
-        ----------
-        url : Optional[str]
-            URL of a script to be added.
-        path : Union[str, pathlib.Path, NoneType]
-            Path to the JavaScript file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory.
-        content : Optional[str]
-            Raw JavaScript content to be injected into frame.
-        type : Optional[str]
-            Script type. Use 'module' in order to load a Javascript ES6 module. See script for more details.
+        Contains the status code of the response (e.g., 200 for a success).
 
         Returns
         -------
-        ElementHandle
+        int
         """
+        return mapping.from_maybe_impl(self._impl_obj.status)
 
-        try:
-            log_api("=> page.add_script_tag started")
-            result = mapping.from_impl(
-                await self._impl_obj.addScriptTag(
-                    url=url, path=path, content=content, type=type
-                )
-            )
-            log_api("<= page.add_script_tag succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.add_script_tag failed")
-            raise e
-
-    async def add_style_tag(
-        self,
-        url: str = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content: str = None,
-    ) -> "ElementHandle":
-        """Page.add_style_tag
-
-        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.
-        Shortcut for main frame's frame.add_style_tag(style).
+    @property
+    def status_text(self) -> str:
+        """APIResponse.status_text
 
-        Parameters
-        ----------
-        url : Optional[str]
-            URL of the `<link>` tag.
-        path : Union[str, pathlib.Path, NoneType]
-            Path to the CSS file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory.
-        content : Optional[str]
-            Raw CSS content to be injected into frame.
+        Contains the status text of the response (e.g. usually an \"OK\" for a success).
 
         Returns
         -------
-        ElementHandle
+        str
         """
+        return mapping.from_maybe_impl(self._impl_obj.status_text)
 
-        try:
-            log_api("=> page.add_style_tag started")
-            result = mapping.from_impl(
-                await self._impl_obj.addStyleTag(url=url, path=path, content=content)
-            )
-            log_api("<= page.add_style_tag succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.add_style_tag failed")
-            raise e
-
-    async def expose_function(self, name: str, binding: typing.Callable) -> NoneType:
-        """Page.expose_function
-
-        The method adds a function called `name` on the `window` object of every frame in the page. When called, the function
-        executes `playwrightFunction` in Node.js and returns a Promise which resolves to the return value of
-        `playwrightFunction`.
-        If the `playwrightFunction` returns a Promise, it will be awaited.
-        See browser_context.expose_function(name, playwrightFunction) for context-wide exposed function.
-
-        **NOTE** Functions installed via `page.expose_function` survive navigations.
-
-        An example of adding an `md5` function to the page:
+    @property
+    def headers(self) -> typing.Dict[str, str]:
+        """APIResponse.headers
 
-        An example of adding a `window.readfile` function to the page:
+        An object with all the response HTTP headers associated with this response.
 
-        Parameters
-        ----------
-        name : str
-            Name of the function on the window object
-        binding : Callable
-            Callback function which will be called in Playwright's context.
+        Returns
+        -------
+        Dict[str, str]
         """
+        return mapping.from_maybe_impl(self._impl_obj.headers)
 
-        try:
-            log_api("=> page.expose_function started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.exposeFunction(
-                    name=name, binding=self._wrap_handler(binding)
-                )
-            )
-            log_api("<= page.expose_function succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.expose_function failed")
-            raise e
-
-    async def expose_binding(
-        self, name: str, binding: typing.Callable, handle: bool = None
-    ) -> NoneType:
-        """Page.expose_binding
+    @property
+    def headers_array(self) -> typing.List[NameValue]:
+        """APIResponse.headers_array
 
-        The method adds a function called `name` on the `window` object of every frame in this page. When called, the function
-        executes `playwrightBinding` in Node.js and returns a Promise which resolves to the return value of
-        `playwrightBinding`. If the `playwrightBinding` returns a Promise, it will be awaited.
-        The first argument of the `playwrightBinding` function contains information about the caller: `{ browserContext: BrowserContext, page: Page, frame: Frame }`.
-        See browser_context.expose_binding(name, playwrightBinding[, options]) for the context-wide version.
+        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.
 
-        **NOTE** Functions installed via `page.expose_binding` survive navigations.
+        Returns
+        -------
+        List[{name: str, value: str}]
+        """
+        return mapping.from_impl_list(self._impl_obj.headers_array)
 
-        An example of exposing page URL to all frames in a page:
+    async def body(self) -> bytes:
+        """APIResponse.body
 
-        An example of passing an element handle:
+        Returns the buffer with response body.
 
-        Parameters
-        ----------
-        name : str
-            Name of the function on the window object.
-        binding : Callable
-            Callback function that will be called in the Playwright's context.
-        handle : Optional[bool]
-            Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is supported. When passing by value, multiple arguments are supported.
+        Returns
+        -------
+        bytes
         """
 
-        try:
-            log_api("=> page.expose_binding started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.exposeBinding(
-                    name=name, binding=self._wrap_handler(binding), handle=handle
-                )
-            )
-            log_api("<= page.expose_binding succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.expose_binding failed")
-            raise e
-
-    async def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneType:
-        """Page.set_extra_http_headers
+        return mapping.from_maybe_impl(await self._impl_obj.body())
 
-        The extra HTTP headers will be sent with every request the page initiates.
+    async def text(self) -> str:
+        """APIResponse.text
 
-        **NOTE** page.set_extra_http_headers does not guarantee the order of headers in the outgoing requests.
+        Returns the text representation of response body.
 
-        Parameters
-        ----------
-        headers : Dict[str, str]
-            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
+        Returns
+        -------
+        str
         """
 
-        try:
-            log_api("=> page.set_extra_http_headers started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.setExtraHTTPHeaders(
-                    headers=mapping.to_impl(headers)
-                )
-            )
-            log_api("<= page.set_extra_http_headers succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_extra_http_headers failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.text())
 
-    async def content(self) -> str:
-        """Page.content
+    async def json(self) -> typing.Any:
+        """APIResponse.json
 
-        Gets the full HTML contents of the page, including the doctype.
+        Returns the JSON representation of response body.
+
+        This method will throw if the response body is not parsable via `JSON.parse`.
 
         Returns
         -------
-        str
+        Any
         """
 
-        try:
-            log_api("=> page.content started")
-            result = mapping.from_maybe_impl(await self._impl_obj.content())
-            log_api("<= page.content succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.content failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.json())
 
-    async def set_content(
-        self,
-        html: str,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-    ) -> NoneType:
-        """Page.set_content
+    async def dispose(self) -> None:
+        """APIResponse.dispose
 
-        Parameters
-        ----------
-        html : str
-            HTML markup to assign to the page.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
+        Disposes the body of this response. If not called then the body will stay in memory until the context closes.
         """
 
-        try:
-            log_api("=> page.set_content started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.setContent(
-                    html=html, timeout=timeout, waitUntil=wait_until
-                )
-            )
-            log_api("<= page.set_content succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_content failed")
-            raise e
-
-    async def goto(
-        self,
-        url: str,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        referer: str = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Page.goto
-
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-        last redirect.
-        `page.goto` will throw an error if:
+        return mapping.from_maybe_impl(await self._impl_obj.dispose())
 
-        there's an SSL error (e.g. in case of self-signed certificates).
-        target URL is invalid.
-        the `timeout` is exceeded during navigation.
-        the remote server does not respond or is unreachable.
-        the main resource failed to load.
 
-        `page.goto` 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().
+mapping.register(APIResponseImpl, APIResponse)
 
-        **NOTE** `page.goto` 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.
 
-        Shortcut for main frame's frame.goto(url[, options])
+class APIRequestContext(AsyncBase):
 
-        Parameters
-        ----------
-        url : str
-            URL to navigate page to. The url should include scheme, e.g. `https://`.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
-        referer : Optional[str]
-            Referer header value. If provided it will take preference over the referer header value set by page.setExtraHTTPHeaders(headers).
+    @property
+    def tracing(self) -> "Tracing":
+        """APIRequestContext.tracing
 
         Returns
         -------
-        Optional[Response]
+        Tracing
         """
+        return mapping.from_impl(self._impl_obj.tracing)
 
-        try:
-            log_api("=> page.goto started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.goto(
-                    url=url, timeout=timeout, waitUntil=wait_until, referer=referer
-                )
-            )
-            log_api("<= page.goto succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.goto failed")
-            raise e
-
-    async def reload(
-        self,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Page.reload
+    async def dispose(self, *, reason: typing.Optional[str] = None) -> None:
+        """APIRequestContext.dispose
 
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-        last redirect.
+        All responses returned by `a_pi_request_context.get()` and similar methods are stored in the memory, so that
+        you can later call `a_pi_response.body()`.This method discards all its resources, calling any method on
+        disposed `APIRequestContext` will throw an exception.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
-
-        Returns
-        -------
-        Optional[Response]
+        reason : Union[str, None]
+            The reason to be reported to the operations interrupted by the context disposal.
         """
 
-        try:
-            log_api("=> page.reload started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.reload(timeout=timeout, waitUntil=wait_until)
-            )
-            log_api("<= page.reload succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.reload failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.dispose(reason=reason))
 
-    async def wait_for_load_state(
+    async def delete(
         self,
-        state: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> NoneType:
-        """Page.wait_for_load_state
-
-        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.
-        Shortcut for main frame's frame.wait_for_load_state([state, options]).
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.delete
+
+        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.
 
         Parameters
         ----------
-        state : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            Load state to wait for, defaults to `load`. If the state has been already reached while loading current document, the method resolves immediately. Optional.
-             - `'load'` - wait for the `load` event to be fired.
-             - `'domcontentloaded'` - wait for the `DOMContentLoaded` event to be fired.
-             - `'networkidle'` - wait until there are no network connections for at least `500` ms.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        """
-
-        try:
-            log_api("=> page.wait_for_load_state started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.waitForLoadState(state=state, timeout=timeout)
-            )
-            log_api("<= page.wait_for_load_state succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_load_state failed")
-            raise e
-
-    async def wait_for_navigation(
-        self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Page.wait_for_navigation
-
-        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`.
-        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:
-        **NOTE** Usage of the History API to change the URL is
-        considered a navigation.
-        Shortcut for main frame's frame.wait_for_navigation([options]).
-
-        Parameters
-        ----------
-        url : Union[str, Pattern, Callable[[str], bool], NoneType]
-            A glob pattern, regex pattern or predicate receiving URL to match while waiting for the navigation.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Optional[Response]
-        """
-
-        try:
-            log_api("=> page.wait_for_navigation started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.waitForNavigation(
-                    url=self._wrap_handler(url), waitUntil=wait_until, timeout=timeout
-                )
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.delete(
+                url=url,
+                params=mapping.to_impl(params),
+                headers=mapping.to_impl(headers),
+                data=mapping.to_impl(data),
+                form=mapping.to_impl(form),
+                multipart=mapping.to_impl(multipart),
+                timeout=to_milliseconds(timeout),
+                failOnStatusCode=fail_on_status_code,
+                ignoreHTTPSErrors=ignore_https_errors,
+                maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
-            log_api("<= page.wait_for_navigation succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_navigation failed")
-            raise e
+        )
 
-    async def wait_for_request(
+    async def head(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        predicate: typing.Union[typing.Callable[["Request"], bool]] = None,
-        timeout: int = None,
-    ) -> "Request":
-        """Page.wait_for_request
-
-        Returns promise that resolves to the matched request.
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.head
+
+        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.
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool], NoneType]
-            Request URL string, regex or predicate receiving Request object.
-        timeout : Optional[int]
-            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) method.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Request
-        """
-
-        try:
-            log_api("=> page.wait_for_request started")
-            result = mapping.from_impl(
-                await self._impl_obj.waitForRequest(
-                    url=self._wrap_handler(url),
-                    predicate=self._wrap_handler(predicate),
-                    timeout=timeout,
-                )
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.head(
+                url=url,
+                params=mapping.to_impl(params),
+                headers=mapping.to_impl(headers),
+                data=mapping.to_impl(data),
+                form=mapping.to_impl(form),
+                multipart=mapping.to_impl(multipart),
+                timeout=to_milliseconds(timeout),
+                failOnStatusCode=fail_on_status_code,
+                ignoreHTTPSErrors=ignore_https_errors,
+                maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
-            log_api("<= page.wait_for_request succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_request failed")
-            raise e
+        )
 
-    async def wait_for_response(
+    async def get(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        predicate: typing.Union[typing.Callable[["Response"], bool]] = None,
-        timeout: int = None,
-    ) -> "Response":
-        """Page.wait_for_response
-
-        Returns the matched response.
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.get
+
+        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:
+
+        ```python
+        query_params = {
+          \"isbn\": \"1234\",
+          \"page\": \"23\"
+        }
+        api_request_context.get(\"https://example.com/api/getText\", params=query_params)
+        ```
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool], NoneType]
-            Request URL string, regex or predicate receiving Response object.
-        timeout : Optional[int]
-            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) or page.setDefaultTimeout(timeout) methods.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Response
-        """
-
-        try:
-            log_api("=> page.wait_for_response started")
-            result = mapping.from_impl(
-                await self._impl_obj.waitForResponse(
-                    url=self._wrap_handler(url),
-                    predicate=self._wrap_handler(predicate),
-                    timeout=timeout,
-                )
-            )
-            log_api("<= page.wait_for_response succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_response failed")
-            raise e
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.get(
+                url=url,
+                params=mapping.to_impl(params),
+                headers=mapping.to_impl(headers),
+                data=mapping.to_impl(data),
+                form=mapping.to_impl(form),
+                multipart=mapping.to_impl(multipart),
+                timeout=to_milliseconds(timeout),
+                failOnStatusCode=fail_on_status_code,
+                ignoreHTTPSErrors=ignore_https_errors,
+                maxRedirects=max_redirects,
+                maxRetries=max_retries,
+            )
+        )
 
-    async def wait_for_event(
+    async def patch(
         self,
-        event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
-    ) -> typing.Any:
-        """Page.wait_for_event
-
-        Returns the event data value.
-        Waits for event to fire and passes its value into the predicate function. Resolves when the predicate returns truthy
-        value. Will throw an error if the page is closed before the event is fired.
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.patch
+
+        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.
 
         Parameters
         ----------
-        event : str
-            Event name, same one would pass into `page.on(event)`.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Any
-        """
-
-        try:
-            log_api("=> page.wait_for_event started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.waitForEvent(
-                    event=event,
-                    predicate=self._wrap_handler(predicate),
-                    timeout=timeout,
-                )
-            )
-            log_api("<= page.wait_for_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_event failed")
-            raise e
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.patch(
+                url=url,
+                params=mapping.to_impl(params),
+                headers=mapping.to_impl(headers),
+                data=mapping.to_impl(data),
+                form=mapping.to_impl(form),
+                multipart=mapping.to_impl(multipart),
+                timeout=to_milliseconds(timeout),
+                failOnStatusCode=fail_on_status_code,
+                ignoreHTTPSErrors=ignore_https_errors,
+                maxRedirects=max_redirects,
+                maxRetries=max_retries,
+            )
+        )
 
-    async def go_back(
+    async def put(
         self,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Page.go_back
-
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-        last redirect. If can not go back, resolves to `null`.
-        Navigate to the previous page in history.
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.put
+
+        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.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Optional[Response]
-        """
-
-        try:
-            log_api("=> page.go_back started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.goBack(timeout=timeout, waitUntil=wait_until)
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.put(
+                url=url,
+                params=mapping.to_impl(params),
+                headers=mapping.to_impl(headers),
+                data=mapping.to_impl(data),
+                form=mapping.to_impl(form),
+                multipart=mapping.to_impl(multipart),
+                timeout=to_milliseconds(timeout),
+                failOnStatusCode=fail_on_status_code,
+                ignoreHTTPSErrors=ignore_https_errors,
+                maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
-            log_api("<= page.go_back succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.go_back failed")
-            raise e
+        )
 
-    async def go_forward(
+    async def post(
         self,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Page.go_forward
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.post
+
+        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:
+
+        ```python
+        data = {
+            \"title\": \"Book Title\",
+            \"body\": \"John Doe\",
+        }
+        api_request_context.post(\"https://example.com/api/createBook\", data=data)
+        ```
 
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-        last redirect. If can not go forward, resolves to `null`.
-        Navigate to the next page in history.
+        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):
+
+        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:
+
+        ```python
+        api_request_context.post(
+          \"https://example.com/api/uploadScript'\",
+          multipart={
+            \"fileField\": {
+              \"name\": \"f.js\",
+              \"mimeType\": \"text/javascript\",
+              \"buffer\": b\"console.log(2022);\",
+            },
+          })
+        ```
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Optional[Response]
-        """
-
-        try:
-            log_api("=> page.go_forward started")
-            result = mapping.from_impl_nullable(
-                await self._impl_obj.goForward(timeout=timeout, waitUntil=wait_until)
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.post(
+                url=url,
+                params=mapping.to_impl(params),
+                headers=mapping.to_impl(headers),
+                data=mapping.to_impl(data),
+                form=mapping.to_impl(form),
+                multipart=mapping.to_impl(multipart),
+                timeout=to_milliseconds(timeout),
+                failOnStatusCode=fail_on_status_code,
+                ignoreHTTPSErrors=ignore_https_errors,
+                maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
-            log_api("<= page.go_forward succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.go_forward failed")
-            raise e
+        )
 
-    async def emulate_media(
+    async def fetch(
         self,
-        media: Literal["print", "screen"] = None,
-        color_scheme: Literal["dark", "light", "no-preference"] = None,
-    ) -> NoneType:
-        """Page.emulate_media
+        url_or_request: typing.Union[str, "Request"],
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        method: typing.Optional[str] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.fetch
+
+        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:
+
+        ```python
+        data = {
+            \"title\": \"Book Title\",
+            \"body\": \"John Doe\",
+        }
+        api_request_context.fetch(\"https://example.com/api/createBook\", method=\"post\", data=data)
+        ```
 
+        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:
 
         Parameters
         ----------
-        media : Optional[Literal['print', 'screen']]
-            Changes the CSS media type of the page. The only allowed values are `'screen'`, `'print'` and `null`. Passing `null` disables CSS media emulation. Omitting `media` or passing `undefined` does not change the emulated value.
-        color_scheme : Optional[Literal['dark', 'light', 'no-preference']]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. Passing `null` disables color scheme emulation. Omitting `colorScheme` or passing `undefined` does not change the emulated value.
-        """
+        url_or_request : Union[Request, str]
+            Target URL or Request to get all parameters from.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        method : Union[str, None]
+            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.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
-        try:
-            log_api("=> page.emulate_media started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.emulateMedia(media=media, colorScheme=color_scheme)
+        Returns
+        -------
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.fetch(
+                urlOrRequest=url_or_request,
+                params=mapping.to_impl(params),
+                method=method,
+                headers=mapping.to_impl(headers),
+                data=mapping.to_impl(data),
+                form=mapping.to_impl(form),
+                multipart=mapping.to_impl(multipart),
+                timeout=to_milliseconds(timeout),
+                failOnStatusCode=fail_on_status_code,
+                ignoreHTTPSErrors=ignore_https_errors,
+                maxRedirects=max_redirects,
+                maxRetries=max_retries,
             )
-            log_api("<= page.emulate_media succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.emulate_media failed")
-            raise e
+        )
 
-    async def set_viewport_size(self, width: int, height: int) -> NoneType:
-        """Page.set_viewport_size
+    async def storage_state(
+        self,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        indexed_db: typing.Optional[bool] = None,
+    ) -> StorageState:
+        """APIRequestContext.storage_state
 
-        In the case of multiple pages in a single browser, each page can have its own viewport size. However,
-        browser.new_context([options]) allows to set viewport size (and more) for all pages in the context at once.
-        `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.
+        Returns storage state for this request context, contains current cookies and local storage snapshot if it was
+        passed to the constructor.
 
         Parameters
         ----------
-        width : int
-            page width in pixels. **required**
-        height : int
-            page height in pixels. **required**
-        """
-
-        try:
-            log_api("=> page.set_viewport_size started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.setViewportSize(width=width, height=height)
-            )
-            log_api("<= page.set_viewport_size succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_viewport_size failed")
-            raise e
-
-    def viewport_size(self) -> typing.Union[typing.Tuple[int, int], NoneType]:
-        """Page.viewport_size
+        path : Union[pathlib.Path, str, None]
+            The file path to save the storage state to. If `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.
+        indexed_db : Union[bool, None]
+            Set to `true` to include IndexedDB in the storage state snapshot.
 
         Returns
         -------
-        Optional[typing.Tuple[int, int]]
+        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
         """
 
-        try:
-            log_api("=> page.viewport_size started")
-            result = mapping.from_maybe_impl(self._impl_obj.viewportSize())
-            log_api("<= page.viewport_size succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.viewport_size failed")
-            raise e
-
-    async def bring_to_front(self) -> NoneType:
-        """Page.bring_to_front
-
-        Brings page to front (activates tab).
-        """
+        return mapping.from_impl(
+            await self._impl_obj.storage_state(path=path, indexedDB=indexed_db)
+        )
 
-        try:
-            log_api("=> page.bring_to_front started")
-            result = mapping.from_maybe_impl(await self._impl_obj.bringToFront())
-            log_api("<= page.bring_to_front succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.bring_to_front failed")
-            raise e
 
-    async def add_init_script(
-        self, source: str = None, path: typing.Union[str, pathlib.Path] = None
-    ) -> NoneType:
-        """Page.add_init_script
+mapping.register(APIRequestContextImpl, APIRequestContext)
 
-        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.
+class APIRequest(AsyncBase):
 
-        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`.
-        An example of overriding `Math.random` before the page loads:
+    async def new_context(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        extra_http_headers: typing.Optional[typing.Dict[str, str]] = None,
+        http_credentials: typing.Optional[HttpCredentials] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        proxy: typing.Optional[ProxySettings] = None,
+        user_agent: typing.Optional[str] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        storage_state: typing.Optional[
+            typing.Union[StorageState, str, pathlib.Path]
+        ] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+    ) -> "APIRequestContext":
+        """APIRequest.new_context
 
-        **NOTE** The order of evaluation of multiple scripts installed via browser_context.add_init_script(script[, arg]) and
-        page.add_init_script(script[, arg]) is not defined.
+        Creates new instances of `APIRequestContext`.
 
         Parameters
         ----------
-        source : Optional[str]
-            Script to be evaluated in the page.
-        """
+        base_url : Union[str, None]
+            Methods like `a_pi_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`
+        extra_http_headers : Union[Dict[str, str], None]
+            An object containing additional HTTP headers to be sent with every request. Defaults to none.
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
+            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.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
+            Network proxy settings.
+        user_agent : Union[str, None]
+            Specific user agent to use in this context.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the response. Defaults to `30000` (30 seconds). Pass `0` to disable
+            timeout.
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
+            Populates context with given storage state. This option can be used to initialize context with logged-in
+            information obtained via `browser_context.storage_state()` or `a_pi_request_context.storage_state()`.
+            Either a path to the file with saved storage, or the value returned by one of
+            `browser_context.storage_state()` or `a_pi_request_context.storage_state()` methods.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            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.
+
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
+
+            **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`.
+
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        max_redirects : Union[int, None]
+            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. This can be overwritten for each request
+            individually.
 
-        try:
-            log_api("=> page.add_init_script started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.addInitScript(source=source, path=path)
+        Returns
+        -------
+        APIRequestContext
+        """
+
+        return mapping.from_impl(
+            await self._impl_obj.new_context(
+                baseURL=base_url,
+                extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                httpCredentials=http_credentials,
+                ignoreHTTPSErrors=ignore_https_errors,
+                proxy=proxy,
+                userAgent=user_agent,
+                timeout=to_milliseconds(timeout),
+                storageState=storage_state,
+                clientCertificates=client_certificates,
+                failOnStatusCode=fail_on_status_code,
+                maxRedirects=max_redirects,
             )
-            log_api("<= page.add_init_script succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.add_init_script failed")
-            raise e
+        )
 
-    async def route(
-        self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]],
-        handler: typing.Union[
-            typing.Callable[["Route"], typing.Any],
-            typing.Callable[["Route", "Request"], typing.Any],
-        ],
-    ) -> NoneType:
-        """Page.route
 
-        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.
+mapping.register(APIRequestImpl, APIRequest)
 
-        **NOTE** The handler will only be called for the first url if the response is a redirect.
 
-        An example of a naïve handler that aborts all image requests:
-        or the same snippet using a regex pattern instead:
-        Page routes take precedence over browser context routes (set up with browser_context.route(url, handler)) when request matches
-        both handlers.
+class PageAssertions(AsyncBase):
 
-        **NOTE** Enabling routing disables http cache.
+    async def to_have_title(
+        self,
+        title_or_reg_exp: typing.Union[typing.Pattern[str], str],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """PageAssertions.to_have_title
 
-        Parameters
-        ----------
-        url : Union[str, Pattern, Callable[[str], bool]]
-            A glob pattern, regex pattern or predicate receiving URL to match while routing.
-        handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any]]
-            handler function to route the request.
-        """
+        Ensures the page has the given title.
 
-        try:
-            log_api("=> page.route started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.route(
-                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
-                )
-            )
-            log_api("<= page.route succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.route failed")
-            raise e
+        **Usage**
 
-    async def unroute(
-        self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]],
-        handler: typing.Union[
-            typing.Callable[["Route"], typing.Any],
-            typing.Callable[["Route", "Request"], typing.Any],
-        ] = None,
-    ) -> NoneType:
-        """Page.unroute
+        ```py
+        import re
+        from playwright.async_api import expect
 
-        Removes a route created with page.route(url, handler). When `handler` is not specified, removes all routes for the `url`.
+        # ...
+        await expect(page).to_have_title(re.compile(r\".*checkout\"))
+        ```
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool]]
-            A glob pattern, regex pattern or predicate receiving URL to match while routing.
-        handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any], NoneType]
-            Optional handler function to route the request.
+        title_or_reg_exp : Union[Pattern[str], str]
+            Expected title or RegExp.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.unroute started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.unroute(
-                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
-                )
-            )
-            log_api("<= page.unroute succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.unroute failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_title(
+                titleOrRegExp=title_or_reg_exp, timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def screenshot(
+    async def not_to_have_title(
         self,
-        timeout: int = None,
-        type: Literal["jpeg", "png"] = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        quality: int = None,
-        omit_background: bool = None,
-        full_page: bool = None,
-        clip: "FloatRect" = None,
-    ) -> bytes:
-        """Page.screenshot
-
-        Returns the buffer with the captured screenshot.
+        title_or_reg_exp: typing.Union[typing.Pattern[str], str],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """PageAssertions.not_to_have_title
 
-        **NOTE** Screenshots take at least 1/6 second on Chromium OS X and Chromium Windows. See https://crbug.com/741689 for
-        discussion.
+        The opposite of `page_assertions.to_have_title()`.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        type : Optional[Literal['jpeg', 'png']]
-            Specify screenshot type, defaults to `png`.
-        path : Union[str, pathlib.Path, NoneType]
-            The file path to save the image to. The screenshot type will be inferred from file extension. If `path` is a relative path, then it is resolved relative to current working directory. If no path is provided, the image won't be saved to the disk.
-        quality : Optional[int]
-            The quality of the image, between 0-100. Not applicable to `png` images.
-        omit_background : Optional[bool]
-            Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images. Defaults to `false`.
-        full_page : Optional[bool]
-            When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Defaults to `false`.
-        clip : Optional[{"x": float, "y": float, "width": float, "height": float}]
-            An object which specifies clipping of the resulting image. Should have the following fields:
-
-        Returns
-        -------
-        bytes
+        title_or_reg_exp : Union[Pattern[str], str]
+            Expected title or RegExp.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.screenshot started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.screenshot(
-                    timeout=timeout,
-                    type=type,
-                    path=path,
-                    quality=quality,
-                    omitBackground=omit_background,
-                    fullPage=full_page,
-                    clip=clip,
-                )
-            )
-            log_api("<= page.screenshot succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.screenshot failed")
-            raise e
-
-    async def title(self) -> str:
-        """Page.title
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_title(
+                titleOrRegExp=title_or_reg_exp, timeout=to_milliseconds(timeout)
+            )
+        )
 
-        Returns the page's title. Shortcut for main frame's frame.title().
+    async def to_have_url(
+        self,
+        url_or_reg_exp: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """PageAssertions.to_have_url
 
-        Returns
-        -------
-        str
-        """
+        Ensures the page is navigated to the given URL.
 
-        try:
-            log_api("=> page.title started")
-            result = mapping.from_maybe_impl(await self._impl_obj.title())
-            log_api("<= page.title succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.title failed")
-            raise e
-
-    async def close(self, run_before_unload: bool = None) -> NoneType:
-        """Page.close
+        **Usage**
 
-        If `runBeforeUnload` is `false` the result will resolve only after the page has been closed. If `runBeforeUnload` is
-        `true` the method will **not** wait for the page to close. By default, `page.close()` **does not** run beforeunload
-        handlers.
+        ```py
+        import re
+        from playwright.async_api import expect
 
-        **NOTE** if `runBeforeUnload` is passed as true, a `beforeunload` dialog might be summoned
-        and should be handled manually via page.on('dialog') event.
+        # ...
+        await expect(page).to_have_url(re.compile(\".*checkout\"))
+        ```
 
         Parameters
         ----------
-        run_before_unload : Optional[bool]
-            Defaults to `false`. Whether to run the before unload page handlers.
-        """
-
-        try:
-            log_api("=> page.close started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.close(runBeforeUnload=run_before_unload)
+        url_or_reg_exp : Union[Pattern[str], str]
+            Expected URL string or RegExp.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression parameter if specified. A provided predicate ignores this flag.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_url(
+                urlOrRegExp=url_or_reg_exp,
+                timeout=to_milliseconds(timeout),
+                ignoreCase=ignore_case,
             )
-            log_api("<= page.close succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.close failed")
-            raise e
-
-    def is_closed(self) -> bool:
-        """Page.is_closed
-
-        Indicates that the page has been closed.
-
-        Returns
-        -------
-        bool
-        """
-
-        try:
-            log_api("=> page.is_closed started")
-            result = mapping.from_maybe_impl(self._impl_obj.isClosed())
-            log_api("<= page.is_closed succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.is_closed failed")
-            raise e
+        )
 
-    async def click(
+    async def not_to_have_url(
         self,
-        selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        click_count: int = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.click
+        url_or_reg_exp: typing.Union[typing.Pattern[str], str],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """PageAssertions.not_to_have_url
 
-        This method clicks an element matching `selector` by performing the following steps:
+        The opposite of `page_assertions.to_have_url()`.
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        Parameters
+        ----------
+        url_or_reg_exp : Union[Pattern[str], str]
+            Expected URL string or RegExp.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_url(
+                urlOrRegExp=url_or_reg_exp,
+                timeout=to_milliseconds(timeout),
+                ignoreCase=ignore_case,
+            )
+        )
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
-        Shortcut for main frame's frame.click(selector[, options]).
+    async def to_match_aria_snapshot(
+        self,
+        expected: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """PageAssertions.to_match_aria_snapshot
+
+        Asserts that the page body matches the given [accessibility snapshot](https://playwright.dev/python/docs/aria-snapshots).
+
+        **Usage**
+
+        ```py
+        await page.goto(\"https://demo.playwright.dev/todomvc/\")
+        await expect(page).to_match_aria_snapshot('''
+          - heading \"todos\"
+          - textbox \"What needs to be done?\"
+        ''')
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
-            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
-            Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.click started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.click(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    clickCount=click_count,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= page.click succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.click failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_match_aria_snapshot(
+                expected=expected, timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def dblclick(
+    async def not_to_match_aria_snapshot(
         self,
-        selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.dblclick
+        expected: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """PageAssertions.not_to_match_aria_snapshot
 
-        This method double clicks an element matching `selector` by performing the following steps:
+        The opposite of `page_assertions.to_match_aria_snapshot()`.
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to double click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if the first click of the `dblclick()` triggers a navigation event, this method will reject.
+        Parameters
+        ----------
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_match_aria_snapshot(
+                expected=expected, timeout=to_milliseconds(timeout)
+            )
+        )
 
-        **NOTE** `page.dblclick()` dispatches two `click` events and a single `dblclick` event.
 
-        Shortcut for main frame's frame.dblclick(selector[, options]).
+mapping.register(PageAssertionsImpl, PageAssertions)
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
-            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
-            Defaults to `left`.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
 
-        try:
-            log_api("=> page.dblclick started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.dblclick(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    delay=delay,
-                    button=button,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= page.dblclick succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.dblclick failed")
-            raise e
+class LocatorAssertions(AsyncBase):
 
-    async def tap(
+    async def to_contain_text(
         self,
-        selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.tap
-
-        This method taps an element matching `selector` by performing the following steps:
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
+        ],
+        *,
+        use_inner_text: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """LocatorAssertions.to_contain_text
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.touchscreen to tap the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        Ensures the `Locator` points to an element that contains the given text. All nested elements will be considered
+        when computing the text content of the element. You can use regular expressions for the value as well.
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        **Details**
 
-        **NOTE** `page.tap()` requires that the `hasTouch` option of the browser context be set to true.
+        When `expected` parameter is a string, Playwright will normalize whitespaces and line breaks both in the actual
+        text and in the expected string before matching. When regular expression is used, the actual text is matched as is.
 
-        Shortcut for main frame's frame.tap(selector[, options]).
+        **Usage**
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        ```py
+        import re
+        from playwright.async_api import expect
 
-        try:
-            log_api("=> page.tap started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.tap(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= page.tap succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.tap failed")
-            raise e
+        locator = page.locator('.title')
+        await expect(locator).to_contain_text(\"substring\")
+        await expect(locator).to_contain_text(re.compile(r\"\\d messages\"))
+        ```
 
-    async def fill(
-        self, selector: str, value: str, timeout: int = None, no_wait_after: bool = None
-    ) -> NoneType:
-        """Page.fill
+        If you pass an array as an expected value, the expectations are:
+        1. Locator resolves to a list of elements.
+        1. Elements from a **subset** of this list contain text from the expected array, respectively.
+        1. The matching subset of elements has the same order as the expected array.
+        1. Each text value from the expected array is matched by some element from the list.
 
-        This method waits for an element matching `selector`, waits for actionability checks, focuses the
-        element, fills it and triggers an `input` event after filling. If the element matching `selector` is not an `<input>`,
-        `<textarea>` or `[contenteditable]` element, this method throws an error. Note that you can pass an empty string to
-        clear the input field.
-        To send fine-grained keyboard events, use page.type(selector, text[, options]).
-        Shortcut for main frame's frame.fill(selector, value[, options])
+        For example, consider the following list:
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        value : str
-            Value to fill for the `<input>`, `<textarea>` or `[contenteditable]` element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        ```html
+        <ul>
+          <li>Item Text 1</li>
+          <li>Item Text 2</li>
+          <li>Item Text 3</li>
+        </ul>
+        ```
 
-        try:
-            log_api("=> page.fill started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.fill(
-                    selector=selector,
-                    value=value,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= page.fill succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.fill failed")
-            raise e
-
-    async def focus(self, selector: str, timeout: int = None) -> NoneType:
-        """Page.focus
+        Let's see how we can use the assertion:
 
-        This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the method
-        waits until a matching element appears in the DOM.
-        Shortcut for main frame's frame.focus(selector[, options]).
+        ```py
+        from playwright.async_api import expect
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        """
+        # ✓ Contains the right items in the right order
+        await expect(page.locator(\"ul > li\")).to_contain_text([\"Text 1\", \"Text 3\"])
 
-        try:
-            log_api("=> page.focus started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.focus(selector=selector, timeout=timeout)
-            )
-            log_api("<= page.focus succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.focus failed")
-            raise e
+        # ✖ Wrong order
+        await expect(page.locator(\"ul > li\")).to_contain_text([\"Text 3\", \"Text 2\"])
 
-    async def text_content(
-        self, selector: str, timeout: int = None
-    ) -> typing.Union[str, NoneType]:
-        """Page.text_content
+        # ✖ No item contains this text
+        await expect(page.locator(\"ul > li\")).to_contain_text([\"Some 33\"])
 
-        Returns `element.textContent`.
+        # ✖ Locator points to the outer list element, not to the list items
+        await expect(page.locator(\"ul\")).to_contain_text([\"Text 3\"])
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-
-        Returns
-        -------
-        Optional[str]
-        """
-
-        try:
-            log_api("=> page.text_content started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.textContent(selector=selector, timeout=timeout)
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected substring or RegExp or a list of those.
+        use_inner_text : Union[bool, None]
+            Whether to use `element.innerText` instead of `element.textContent` when retrieving DOM node text.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_contain_text(
+                expected=mapping.to_impl(expected),
+                useInnerText=use_inner_text,
+                timeout=to_milliseconds(timeout),
+                ignoreCase=ignore_case,
             )
-            log_api("<= page.text_content succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.text_content failed")
-            raise e
+        )
 
-    async def inner_text(self, selector: str, timeout: int = None) -> str:
-        """Page.inner_text
+    async def not_to_contain_text(
+        self,
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
+        ],
+        *,
+        use_inner_text: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_contain_text
 
-        Returns `element.innerText`.
+        The opposite of `locator_assertions.to_contain_text()`.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected substring or RegExp or a list of those.
+        use_inner_text : Union[bool, None]
+            Whether to use `element.innerText` instead of `element.textContent` when retrieving DOM node text.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_contain_text(
+                expected=mapping.to_impl(expected),
+                useInnerText=use_inner_text,
+                timeout=to_milliseconds(timeout),
+                ignoreCase=ignore_case,
+            )
+        )
 
-        Returns
-        -------
-        str
-        """
+    async def to_have_attribute(
+        self,
+        name: str,
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_attribute
 
-        try:
-            log_api("=> page.inner_text started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.innerText(selector=selector, timeout=timeout)
-            )
-            log_api("<= page.inner_text succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.inner_text failed")
-            raise e
+        Ensures the `Locator` points to an element with given attribute.
 
-    async def inner_html(self, selector: str, timeout: int = None) -> str:
-        """Page.inner_html
+        **Usage**
 
-        Returns `element.innerHTML`.
+        ```py
+        from playwright.async_api import expect
+
+        locator = page.locator(\"input\")
+        await expect(locator).to_have_attribute(\"type\", \"text\")
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-
-        Returns
-        -------
-        str
-        """
-
-        try:
-            log_api("=> page.inner_html started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.innerHTML(selector=selector, timeout=timeout)
+        name : str
+            Attribute name.
+        value : Union[Pattern[str], str]
+            Expected attribute value.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_attribute(
+                name=name,
+                value=value,
+                ignoreCase=ignore_case,
+                timeout=to_milliseconds(timeout),
             )
-            log_api("<= page.inner_html succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.inner_html failed")
-            raise e
+        )
 
-    async def get_attribute(
-        self, selector: str, name: str, timeout: int = None
-    ) -> typing.Union[str, NoneType]:
-        """Page.get_attribute
+    async def not_to_have_attribute(
+        self,
+        name: str,
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_attribute
 
-        Returns element attribute value.
+        The opposite of `locator_assertions.to_have_attribute()`.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
         name : str
-            Attribute name to get the value for.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-
-        Returns
-        -------
-        Optional[str]
-        """
-
-        try:
-            log_api("=> page.get_attribute started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.getAttribute(
-                    selector=selector, name=name, timeout=timeout
-                )
-            )
-            log_api("<= page.get_attribute succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.get_attribute failed")
-            raise e
+            Attribute name.
+        value : Union[Pattern[str], str]
+            Expected attribute value.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_attribute(
+                name=name,
+                value=value,
+                ignoreCase=ignore_case,
+                timeout=to_milliseconds(timeout),
+            )
+        )
 
-    async def hover(
+    async def to_have_class(
         self,
-        selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-    ) -> NoneType:
-        """Page.hover
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_class
 
-        This method hovers over an element matching `selector` by performing the following steps:
+        Ensures the `Locator` points to an element with given CSS classes. When a string is provided, it must fully match
+        the element's `class` attribute. To match individual classes use `locator_assertions.to_contain_class()`.
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to hover over the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        **Usage**
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
-        Shortcut for main frame's frame.hover(selector[, options]).
+        ```html
+        <div class='middle selected row' id='component'></div>
+        ```
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        """
+        ```py
+        from playwright.async_api import expect
 
-        try:
-            log_api("=> page.hover started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.hover(
-                    selector=selector,
-                    modifiers=modifiers,
-                    position=position,
-                    timeout=timeout,
-                    force=force,
-                )
-            )
-            log_api("<= page.hover succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.hover failed")
-            raise e
+        locator = page.locator(\"#component\")
+        await expect(locator).to_have_class(\"middle selected row\")
+        await expect(locator).to_have_class(re.compile(r\"(^|\\\\s)selected(\\\\s|$)\"))
+        ```
 
-    async def select_option(
-        self,
-        selector: str,
-        value: typing.Union[str, typing.List[str]] = None,
-        index: typing.Union[int, typing.List[int]] = None,
-        label: typing.Union[str, typing.List[str]] = None,
-        element: typing.Union["ElementHandle", typing.List["ElementHandle"]] = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> typing.List[str]:
-        """Page.select_option
+        When an array is passed, the method asserts that the list of elements located matches the corresponding list of
+        expected class values. Each element's class attribute is matched against the corresponding string or regular
+        expression in the array:
 
-        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. If there's no `<select>` element
-        matching `selector`, the method throws an error.
+        ```py
+        from playwright.async_api import expect
 
-        Shortcut for main frame's frame.select_option(selector, values[, options])
+        locator = page.locator(\".list > .component\")
+        await expect(locator).to_have_class([\"component\", \"component selected\", \"component\"])
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-
-        Returns
-        -------
-        List[str]
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected class or RegExp or a list of those.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.select_option started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.selectOption(
-                    selector=selector,
-                    value=value,
-                    index=index,
-                    label=label,
-                    element=mapping.to_impl(element),
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= page.select_option succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.select_option failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_class(
+                expected=mapping.to_impl(expected), timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def set_input_files(
+    async def not_to_have_class(
         self,
-        selector: str,
-        files: typing.Union[
-            str, "FilePayload", typing.List[str], typing.List["FilePayload"]
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
         ],
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.set_input_files
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_class
 
-        This method expects `selector` to point to an input
-        element.
-        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.
+        The opposite of `locator_assertions.to_have_class()`.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        files : Union[str, Dict, List[str], List[Dict]]
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected class or RegExp or a list of those.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.set_input_files started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.setInputFiles(
-                    selector=selector,
-                    files=files,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= page.set_input_files succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_input_files failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_class(
+                expected=mapping.to_impl(expected), timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def type(
+    async def to_contain_class(
         self,
-        selector: str,
-        text: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.type
+        expected: typing.Union[typing.Sequence[str], str],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_contain_class
 
-        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]).
-        To press a special key, like `Control` or `ArrowDown`, use keyboard.press(key[, options]).
-        Shortcut for main frame's frame.type(selector, text[, options]).
+        Ensures the `Locator` points to an element with given CSS classes. All classes from the asserted value, separated
+        by spaces, must be present in the
+        [Element.classList](https://developer.mozilla.org/en-US/docs/Web/API/Element/classList) in any order.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        text : str
-            A text to type into a focused element.
-        delay : Optional[int]
-            Time to wait between key presses in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        **Usage**
 
-        try:
-            log_api("=> page.type started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.type(
-                    selector=selector,
-                    text=text,
-                    delay=delay,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= page.type succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.type failed")
-            raise e
+        ```html
+        <div class='middle selected row' id='component'></div>
+        ```
 
-    async def press(
-        self,
-        selector: str,
-        key: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.press
+        ```py
+        from playwright.async_api import expect
 
-        Focuses the element, and then uses keyboard.down(key) and keyboard.up(key).
-        `key` can specify the intended keyboardEvent.key
-        value or a single character to generate the text for. A superset of the `key` values can be found
-        here. 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 suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
-        Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
-        If `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"` or `key: "Control+Shift+T"` are supported as well. When speficied with the
-        modifier, modifier is pressed and being held while the subsequent key is being pressed.
+        locator = page.locator(\"#component\")
+        await expect(locator).to_contain_class(\"middle selected row\")
+        await expect(locator).to_contain_class(\"selected\")
+        await expect(locator).to_contain_class(\"row middle\")
+        ```
+
+        When an array is passed, the method asserts that the list of elements located matches the corresponding list of
+        expected class lists. Each element's class attribute is matched against the corresponding class in the array:
+
+        ```html
+        <div class='list'>
+          <div class='component inactive'></div>
+          <div class='component active'></div>
+          <div class='component inactive'></div>
+        </div>
+        ```
+
+        ```py
+        from playwright.async_api import expect
+
+        locator = page.locator(\".list > .component\")
+        await expect(locator).to_contain_class([\"inactive\", \"active\", \"inactive\"])
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        key : str
-            Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
-        delay : Optional[int]
-            Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
+        expected : Union[Sequence[str], str]
+            A string containing expected class names, separated by spaces, or a list of such strings to assert multiple
+            elements.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.press started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.press(
-                    selector=selector,
-                    key=key,
-                    delay=delay,
-                    timeout=timeout,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= page.press succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.press failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_contain_class(
+                expected=mapping.to_impl(expected), timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def check(
+    async def not_to_contain_class(
         self,
-        selector: str,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.check
-
-        This method checks an element matching `selector` by performing the following steps:
-
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already checked, this method returns immediately.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now checked. If not, this method rejects.
+        expected: typing.Union[typing.Sequence[str], str],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_contain_class
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
-        Shortcut for main frame's frame.check(selector[, options]).
+        The opposite of `locator_assertions.to_contain_class()`.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
+        expected : Union[Sequence[str], str]
+            Expected class or RegExp or a list of those.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.check started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.check(
-                    selector=selector,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= page.check succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.check failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_contain_class(
+                expected=mapping.to_impl(expected), timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def uncheck(
+    async def to_have_count(
         self,
-        selector: str,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.uncheck
+        count: int,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_count
 
-        This method unchecks an element matching `selector` by performing the following steps:
-
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already unchecked, this method returns immediately.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now unchecked. If not, this method rejects.
-
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
-        Shortcut for main frame's frame.uncheck(selector[, options]).
+        Ensures the `Locator` resolves to an exact number of DOM nodes.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        **Usage**
 
-        try:
-            log_api("=> page.uncheck started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.uncheck(
-                    selector=selector,
-                    timeout=timeout,
-                    force=force,
-                    noWaitAfter=no_wait_after,
-                )
-            )
-            log_api("<= page.uncheck succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.uncheck failed")
-            raise e
-
-    async def wait_for_timeout(self, timeout: int) -> NoneType:
-        """Page.wait_for_timeout
+        ```py
+        from playwright.async_api import expect
 
-        Returns a promise that resolves after the timeout.
-        Note that `page.wait_for_timeout()` 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.
-        Shortcut for main frame's frame.wait_for_timeout(timeout).
+        locator = page.locator(\"list > .component\")
+        await expect(locator).to_have_count(3)
+        ```
 
         Parameters
         ----------
-        timeout : int
-            A timeout to wait for
+        count : int
+            Expected count.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.wait_for_timeout started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.waitForTimeout(timeout=timeout)
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_count(
+                count=count, timeout=to_milliseconds(timeout)
             )
-            log_api("<= page.wait_for_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_timeout failed")
-            raise e
+        )
 
-    async def wait_for_function(
+    async def not_to_have_count(
         self,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-        timeout: int = None,
-        polling: typing.Union[int, Literal["raf"]] = None,
-    ) -> "JSHandle":
-        """Page.wait_for_function
+        count: int,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_count
 
-        Returns when the `pageFunction` returns a truthy value. It resolves to a JSHandle of the truthy value.
-        The `waitForFunction` can be used to observe viewport size change:
-
-        To pass an argument from Node.js to the predicate of `page.wait_for_function` function:
-        Shortcut for main frame's frame.wait_for_function(pageFunction[, arg, options]).
+        The opposite of `locator_assertions.to_have_count()`.
 
         Parameters
         ----------
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
-        timeout : Optional[int]
-            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).
-        polling : Union[int, 'raf', NoneType]
-            If `polling` is `'raf'`, then `pageFunction` is constantly executed in `requestAnimationFrame` callback. If `polling` is a number, then it is treated as an interval in milliseconds at which the function would be executed. Defaults to `raf`.
-
-        Returns
-        -------
-        JSHandle
+        count : int
+            Expected count.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.wait_for_function started")
-            result = mapping.from_impl(
-                await self._impl_obj.waitForFunction(
-                    expression=expression,
-                    arg=mapping.to_impl(arg),
-                    force_expr=force_expr,
-                    timeout=timeout,
-                    polling=polling,
-                )
-            )
-            log_api("<= page.wait_for_function succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_function failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_count(
+                count=count, timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def pdf(
+    async def to_have_css(
         self,
-        scale: int = None,
-        display_header_footer: bool = None,
-        header_template: str = None,
-        footer_template: str = None,
-        print_background: bool = None,
-        landscape: bool = None,
-        page_ranges: str = None,
-        format: str = None,
-        width: typing.Union[str, float] = None,
-        height: typing.Union[str, float] = None,
-        prefer_css_page_size: bool = None,
-        margin: "PdfMargins" = None,
-        path: typing.Union[str, pathlib.Path] = None,
-    ) -> bytes:
-        """Page.pdf
+        name: str,
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        pseudo: typing.Optional[Literal["after", "before"]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_css
 
-        Returns the PDF buffer.
+        Ensures the `Locator` resolves to an element with the given computed CSS style.
 
-        **NOTE** Generating a pdf is currently only supported in Chromium headless.
+        **Usage**
 
-        `page.pdf()` generates a pdf of the page with `print` css media. To generate a pdf with `screen` media, call
-        page.emulate_media(params) before calling `page.pdf()`:
+        ```py
+        from playwright.async_api import expect
 
-        **NOTE** By default, `page.pdf()` generates a pdf with modified colors for printing. Use the
-        `-webkit-print-color-adjust` property to
-        force rendering of exact colors.
+        locator = page.get_by_role(\"button\")
+        await expect(locator).to_have_css(\"display\", \"flex\")
+        ```
 
-        The `width`, `height`, and `margin` options accept values labeled with units. Unlabeled values are treated as pixels.
-        A few examples:
+        Parameters
+        ----------
+        name : str
+            CSS property name.
+        value : Union[Pattern[str], str]
+            CSS property value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        pseudo : Union["after", "before", None]
+            Pseudo-element to read computed styles from.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_css(
+                name=name, value=value, timeout=to_milliseconds(timeout), pseudo=pseudo
+            )
+        )
 
-        `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.
+    async def not_to_have_css(
+        self,
+        name: str,
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_css
 
-        All possible units are:
+        The opposite of `locator_assertions.to_have_css()`.
 
-        `px` - pixel
-        `in` - inch
-        `cm` - centimeter
-        `mm` - millimeter
+        Parameters
+        ----------
+        name : str
+            CSS property name.
+        value : Union[Pattern[str], str]
+            CSS property value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
 
-        The `format` options are:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_css(
+                name=name, value=value, timeout=to_milliseconds(timeout)
+            )
+        )
+
+    async def to_have_id(
+        self,
+        id: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_id
+
+        Ensures the `Locator` points to an element with the given DOM Node ID.
 
-        `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
+        **Usage**
 
-        **NOTE** `headerTemplate` and `footerTemplate` markup have the following limitations:
+        ```py
+        from playwright.async_api import expect
 
-        Script tags inside templates are not evaluated.
-        Page styles are not visible inside templates.
+        locator = page.get_by_role(\"textbox\")
+        await expect(locator).to_have_id(\"lastname\")
+        ```
 
         Parameters
         ----------
-        scale : Optional[int]
-            Scale of the webpage rendering. Defaults to `1`. Scale amount must be between 0.1 and 2.
-        display_header_footer : Optional[bool]
-            Display header and footer. Defaults to `false`.
-        header_template : Optional[str]
-            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
-        footer_template : Optional[str]
-            HTML template for the print footer. Should use the same format as the `headerTemplate`.
-        print_background : Optional[bool]
-            Print background graphics. Defaults to `false`.
-        landscape : Optional[bool]
-            Paper orientation. Defaults to `false`.
-        page_ranges : Optional[str]
-            Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty string, which means print all pages.
-        format : Optional[str]
-            Paper format. If set, takes priority over `width` or `height` options. Defaults to 'Letter'.
-        width : Union[str, float, NoneType]
-            Paper width, accepts values labeled with units.
-        height : Union[str, float, NoneType]
-            Paper height, accepts values labeled with units.
-        prefer_css_page_size : Optional[bool]
-            Give any CSS `@page` size declared in the page priority over what is declared in `width` and `height` or `format` options. Defaults to `false`, which will scale the content to fit the paper size.
-        margin : Optional[{"top": Union[str, int, NoneType], "right": Union[str, int, NoneType], "bottom": Union[str, int, NoneType], "left": Union[str, int, NoneType]}]
-            Paper margins, defaults to none.
-        path : Union[str, pathlib.Path, NoneType]
-            The file path to save the PDF to. If `path` is a relative path, then it is resolved relative to current working directory. If no path is provided, the PDF won't be saved to the disk.
-
-        Returns
-        -------
-        bytes
+        id : Union[Pattern[str], str]
+            Element id.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.pdf started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.pdf(
-                    scale=scale,
-                    displayHeaderFooter=display_header_footer,
-                    headerTemplate=header_template,
-                    footerTemplate=footer_template,
-                    printBackground=print_background,
-                    landscape=landscape,
-                    pageRanges=page_ranges,
-                    format=format,
-                    width=width,
-                    height=height,
-                    preferCSSPageSize=prefer_css_page_size,
-                    margin=margin,
-                    path=path,
-                )
-            )
-            log_api("<= page.pdf succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.pdf failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_id(id=id, timeout=to_milliseconds(timeout))
+        )
 
-    def expect_event(
+    async def not_to_have_id(
         self,
-        event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager:
-        """Page.expect_event
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        id: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_id
 
-        async with page.expect_event() as event_info:
-            await page.click("button")
-        value = event_info.value
+        The opposite of `locator_assertions.to_have_id()`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        id : Union[Pattern[str], str]
+            Element id.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        return AsyncEventContextManager(
-            self._impl_obj.waitForEvent(event, predicate, timeout)
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_id(id=id, timeout=to_milliseconds(timeout))
         )
 
-    def expect_console_message(
+    async def to_have_js_property(
         self,
-        predicate: typing.Union[typing.Callable[["ConsoleMessage"], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager["ConsoleMessage"]:
-        """Page.expect_console_message
+        name: str,
+        value: typing.Any,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_js_property
+
+        Ensures the `Locator` points to an element with given JavaScript property. Note that this property can be of a
+        primitive type as well as a plain serializable JavaScript object.
+
+        **Usage**
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        ```py
+        from playwright.async_api import expect
 
-        async with page.expect_console() as event_info:
-            await page.click("button")
-        value = event_info.value
+        locator = page.locator(\".component\")
+        await expect(locator).to_have_js_property(\"loaded\", True)
+        ```
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        event = "console"
-        return AsyncEventContextManager(
-            self._impl_obj.waitForEvent(event, predicate, timeout)
+        name : str
+            Property name.
+        value : Any
+            Property value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_js_property(
+                name=name,
+                value=mapping.to_impl(value),
+                timeout=to_milliseconds(timeout),
+            )
         )
 
-    def expect_dialog(
+    async def not_to_have_js_property(
         self,
-        predicate: typing.Union[typing.Callable[["Dialog"], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager["Dialog"]:
-        """Page.expect_dialog
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        name: str,
+        value: typing.Any,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_js_property
 
-        async with page.expect_dialog() as event_info:
-            await page.click("button")
-        value = event_info.value
+        The opposite of `locator_assertions.to_have_js_property()`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        event = "dialog"
-        return AsyncEventContextManager(
-            self._impl_obj.waitForEvent(event, predicate, timeout)
+        name : str
+            Property name.
+        value : Any
+            Property value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_js_property(
+                name=name,
+                value=mapping.to_impl(value),
+                timeout=to_milliseconds(timeout),
+            )
         )
 
-    def expect_download(
+    async def to_have_value(
         self,
-        predicate: typing.Union[typing.Callable[["Download"], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager["Download"]:
-        """Page.expect_download
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_value
+
+        Ensures the `Locator` points to an element with the given input value. You can use regular expressions for the
+        value as well.
+
+        **Usage**
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        ```py
+        import re
+        from playwright.async_api import expect
 
-        async with page.expect_download() as event_info:
-            await page.click("button")
-        value = event_info.value
+        locator = page.locator(\"input[type=number]\")
+        await expect(locator).to_have_value(re.compile(r\"[0-9]\"))
+        ```
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        value : Union[Pattern[str], str]
+            Expected value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        event = "download"
-        return AsyncEventContextManager(
-            self._impl_obj.waitForEvent(event, predicate, timeout)
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_value(
+                value=value, timeout=to_milliseconds(timeout)
+            )
         )
 
-    def expect_file_chooser(
+    async def not_to_have_value(
         self,
-        predicate: typing.Union[typing.Callable[["FileChooser"], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager["FileChooser"]:
-        """Page.expect_file_chooser
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_value
 
-        async with page.expect_filechooser() as event_info:
-            await page.click("button")
-        value = event_info.value
+        The opposite of `locator_assertions.to_have_value()`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        value : Union[Pattern[str], str]
+            Expected value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        event = "filechooser"
-        return AsyncEventContextManager(
-            self._impl_obj.waitForEvent(event, predicate, timeout)
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_value(
+                value=value, timeout=to_milliseconds(timeout)
+            )
         )
 
-    def expect_load_state(
+    async def to_have_values(
         self,
-        state: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager[typing.Union["Response", NoneType]]:
-        """Page.expect_load_state
+        values: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_values
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        Ensures the `Locator` points to multi-select/combobox (i.e. a `select` with the `multiple` attribute) and the
+        specified values are selected.
 
-        async with page.expect_loadstate() as event_info:
-            await page.click("button")
-        value = event_info.value
+        **Usage**
 
-        Parameters
-        ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        return AsyncEventContextManager(self._impl_obj.waitForLoadState(state, timeout))
+        For example, given the following element:
 
-    def expect_navigation(
-        self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager[typing.Union["Response", NoneType]]:
-        """Page.expect_navigation
+        ```html
+        <select id=\"favorite-colors\" multiple>
+          <option value=\"R\">Red</option>
+          <option value=\"G\">Green</option>
+          <option value=\"B\">Blue</option>
+        </select>
+        ```
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        ```py
+        import re
+        from playwright.async_api import expect
 
-        async with page.expect_navigation() as event_info:
-            await page.click("button")
-        value = event_info.value
+        locator = page.locator(\"id=favorite-colors\")
+        await locator.select_option([\"R\", \"G\"])
+        await expect(locator).to_have_values([re.compile(r\"R\"), re.compile(r\"G\")])
+        ```
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        values : Union[Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str]]
+            Expected options currently selected.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        return AsyncEventContextManager(
-            self._impl_obj.waitForNavigation(url, wait_until, timeout)
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_values(
+                values=mapping.to_impl(values), timeout=to_milliseconds(timeout)
+            )
         )
 
-    def expect_popup(
+    async def not_to_have_values(
         self,
-        predicate: typing.Union[typing.Callable[["Page"], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager["Page"]:
-        """Page.expect_popup
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        values: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_values
 
-        async with page.expect_popup() as event_info:
-            await page.click("button")
-        value = event_info.value
+        The opposite of `locator_assertions.to_have_values()`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        values : Union[Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str]]
+            Expected options currently selected.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        event = "popup"
-        return AsyncEventContextManager(
-            self._impl_obj.waitForEvent(event, predicate, timeout)
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_values(
+                values=mapping.to_impl(values), timeout=to_milliseconds(timeout)
+            )
         )
 
-    def expect_request(
+    async def to_have_text(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        predicate: typing.Union[typing.Callable[["Request"], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager["Request"]:
-        """Page.expect_request
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
+        ],
+        *,
+        use_inner_text: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_text
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        Ensures the `Locator` points to an element with the given text. All nested elements will be considered when
+        computing the text content of the element. You can use regular expressions for the value as well.
 
-        async with page.expect_request() as event_info:
-            await page.click("button")
-        value = event_info.value
+        **Details**
 
-        Parameters
-        ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        return AsyncEventContextManager(
-            self._impl_obj.waitForRequest(url, predicate, timeout)
-        )
+        When `expected` parameter is a string, Playwright will normalize whitespaces and line breaks both in the actual
+        text and in the expected string before matching. When regular expression is used, the actual text is matched as is.
 
-    def expect_response(
-        self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        predicate: typing.Union[typing.Callable[["Request"], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager["Response"]:
-        """Page.expect_response
+        **Usage**
+
+        ```py
+        import re
+        from playwright.async_api import expect
+
+        locator = page.locator(\".title\")
+        await expect(locator).to_have_text(re.compile(r\"Welcome, Test User\"))
+        await expect(locator).to_have_text(re.compile(r\"Welcome, .*\"))
+        ```
+
+        If you pass an array as an expected value, the expectations are:
+        1. Locator resolves to a list of elements.
+        1. The number of elements equals the number of expected values in the array.
+        1. Elements from the list have text matching expected array values, one by one, in order.
+
+        For example, consider the following list:
+
+        ```html
+        <ul>
+          <li>Text 1</li>
+          <li>Text 2</li>
+          <li>Text 3</li>
+        </ul>
+        ```
+
+        Let's see how we can use the assertion:
+
+        ```py
+        from playwright.async_api import expect
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        # ✓ Has the right items in the right order
+        await expect(page.locator(\"ul > li\")).to_have_text([\"Text 1\", \"Text 2\", \"Text 3\"])
 
-        async with page.expect_response() as event_info:
-            await page.click("button")
-        value = event_info.value
+        # ✖ Wrong order
+        await expect(page.locator(\"ul > li\")).to_have_text([\"Text 3\", \"Text 2\", \"Text 1\"])
+
+        # ✖ Last item does not match
+        await expect(page.locator(\"ul > li\")).to_have_text([\"Text 1\", \"Text 2\", \"Text\"])
+
+        # ✖ Locator points to the outer list element, not to the list items
+        await expect(page.locator(\"ul\")).to_have_text([\"Text 1\", \"Text 2\", \"Text 3\"])
+        ```
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        return AsyncEventContextManager(
-            self._impl_obj.waitForResponse(url, predicate, timeout)
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected string or RegExp or a list of those.
+        use_inner_text : Union[bool, None]
+            Whether to use `element.innerText` instead of `element.textContent` when retrieving DOM node text.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_text(
+                expected=mapping.to_impl(expected),
+                useInnerText=use_inner_text,
+                timeout=to_milliseconds(timeout),
+                ignoreCase=ignore_case,
+            )
         )
 
-    def expect_worker(
+    async def not_to_have_text(
         self,
-        predicate: typing.Union[typing.Callable[["Worker"], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager["Worker"]:
-        """Page.expect_worker
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
+        ],
+        *,
+        use_inner_text: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_text
 
-        async with page.expect_worker() as event_info:
-            await page.click("button")
-        value = event_info.value
+        The opposite of `locator_assertions.to_have_text()`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        event = "worker"
-        return AsyncEventContextManager(
-            self._impl_obj.waitForEvent(event, predicate, timeout)
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected string or RegExp or a list of those.
+        use_inner_text : Union[bool, None]
+            Whether to use `element.innerText` instead of `element.textContent` when retrieving DOM node text.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_text(
+                expected=mapping.to_impl(expected),
+                useInnerText=use_inner_text,
+                timeout=to_milliseconds(timeout),
+                ignoreCase=ignore_case,
+            )
         )
 
+    async def to_be_attached(
+        self,
+        *,
+        attached: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_attached
 
-mapping.register(PageImpl, Page)
+        Ensures that `Locator` points to an element that is
+        [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.
 
+        **Usage**
 
-class BrowserContext(AsyncBase):
-    def __init__(self, obj: BrowserContextImpl):
-        super().__init__(obj)
+        ```py
+        await expect(page.get_by_text(\"Hidden text\")).to_be_attached()
+        ```
 
-    @property
-    def pages(self) -> typing.List["Page"]:
-        """BrowserContext.pages
+        Parameters
+        ----------
+        attached : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
 
-        Returns all open pages in the context. Non visible pages, such as `"background_page"`, will not be listed here. You can
-        find them using chromium_browser_context.background_pages().
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_be_attached(
+                attached=attached, timeout=to_milliseconds(timeout)
+            )
+        )
 
-        Returns
-        -------
-        List[Page]
-        """
-        return mapping.from_impl_list(self._impl_obj.pages)
+    async def to_be_checked(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        checked: typing.Optional[bool] = None,
+        indeterminate: typing.Optional[bool] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_checked
 
-    @property
-    def browser(self) -> typing.Union["Browser", NoneType]:
-        """BrowserContext.browser
+        Ensures the `Locator` points to a checked input.
 
-        Returns the browser instance of the context. If it was launched as a persistent context null gets returned.
+        **Usage**
 
-        Returns
-        -------
-        Optional[Browser]
-        """
-        return mapping.from_impl_nullable(self._impl_obj.browser)
+        ```py
+        from playwright.async_api import expect
 
-    def set_default_navigation_timeout(self, timeout: int) -> NoneType:
-        """BrowserContext.set_default_navigation_timeout
+        locator = page.get_by_label(\"Subscribe to newsletter\")
+        await expect(locator).to_be_checked()
+        ```
 
-        This setting will change the default maximum navigation time for the following methods and related shortcuts:
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        checked : Union[bool, None]
+            Provides state to assert for. Asserts for input to be checked by default. This option can't be used when
+            `indeterminate` is set to true.
+        indeterminate : Union[bool, None]
+            Asserts that the element is in the indeterminate (mixed) state. Only supported for checkboxes and radio buttons.
+            This option can't be true when `checked` is provided.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_be_checked(
+                timeout=to_milliseconds(timeout),
+                checked=checked,
+                indeterminate=indeterminate,
+            )
+        )
 
-        page.go_back([options])
-        page.go_forward([options])
-        page.goto(url[, options])
-        page.reload([options])
-        page.set_content(html[, options])
-        page.wait_for_navigation([options])
+    async def not_to_be_attached(
+        self,
+        *,
+        attached: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_attached
 
-        **NOTE** page.set_default_navigation_timeout(timeout) and page.set_default_timeout(timeout) take priority over
-        browser_context.set_default_navigation_timeout(timeout).
+        The opposite of `locator_assertions.to_be_attached()`.
 
         Parameters
         ----------
-        timeout : int
-            Maximum navigation time in milliseconds
+        attached : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.set_default_navigation_timeout started")
-            result = mapping.from_maybe_impl(
-                self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_be_attached(
+                attached=attached, timeout=to_milliseconds(timeout)
             )
-            log_api("<= browser_context.set_default_navigation_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.set_default_navigation_timeout failed")
-            raise e
-
-    def set_default_timeout(self, timeout: int) -> NoneType:
-        """BrowserContext.set_default_timeout
+        )
 
-        This setting will change the default maximum time for all the methods accepting `timeout` option.
+    async def not_to_be_checked(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_checked
 
-        **NOTE** page.set_default_navigation_timeout(timeout), page.set_default_timeout(timeout) and
-        browser_context.set_default_navigation_timeout(timeout) take priority over browser_context.set_default_timeout(timeout).
+        The opposite of `locator_assertions.to_be_checked()`.
 
         Parameters
         ----------
-        timeout : int
-            Maximum time in milliseconds
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.set_default_timeout started")
-            result = mapping.from_maybe_impl(
-                self._impl_obj.setDefaultTimeout(timeout=timeout)
-            )
-            log_api("<= browser_context.set_default_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.set_default_timeout failed")
-            raise e
-
-    async def new_page(self) -> "Page":
-        """BrowserContext.new_page
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_be_checked(timeout=to_milliseconds(timeout))
+        )
 
-        Creates a new page in the browser context.
+    async def to_be_disabled(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_disabled
 
-        Returns
-        -------
-        Page
-        """
+        Ensures the `Locator` points to a disabled element. Element is disabled if it has \"disabled\" attribute or is
+        disabled via
+        ['aria-disabled'](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-disabled). Note
+        that only native control elements such as HTML `button`, `input`, `select`, `textarea`, `option`, `optgroup` can be
+        disabled by setting \"disabled\" attribute. \"disabled\" attribute on other elements is ignored by the browser.
 
-        try:
-            log_api("=> browser_context.new_page started")
-            result = mapping.from_impl(await self._impl_obj.newPage())
-            log_api("<= browser_context.new_page succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.new_page failed")
-            raise e
+        **Usage**
 
-    async def cookies(
-        self, urls: typing.Union[str, typing.List[str]] = None
-    ) -> typing.List["Cookie"]:
-        """BrowserContext.cookies
+        ```py
+        from playwright.async_api import expect
 
-        If no URLs are specified, this method returns all cookies. If URLs are specified, only cookies that affect those URLs
-        are returned.
+        locator = page.locator(\"button.submit\")
+        await expect(locator).to_be_disabled()
+        ```
 
         Parameters
         ----------
-        urls : Union[str, List[str], NoneType]
-            Optional list of URLs.
-
-        Returns
-        -------
-        List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.cookies started")
-            result = mapping.from_impl_list(await self._impl_obj.cookies(urls=urls))
-            log_api("<= browser_context.cookies succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.cookies failed")
-            raise e
-
-    async def add_cookies(self, cookies: typing.List["Cookie"]) -> NoneType:
-        """BrowserContext.add_cookies
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_be_disabled(timeout=to_milliseconds(timeout))
+        )
 
-        Adds cookies into this browser context. All pages within this context will have these cookies installed. Cookies can be
-        obtained via browser_context.cookies([urls]).
+    async def not_to_be_disabled(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_disabled
+
+        The opposite of `locator_assertions.to_be_disabled()`.
 
         Parameters
         ----------
-        cookies : List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.add_cookies started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.addCookies(cookies=cookies)
-            )
-            log_api("<= browser_context.add_cookies succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.add_cookies failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_be_disabled(timeout=to_milliseconds(timeout))
+        )
 
-    async def clear_cookies(self) -> NoneType:
-        """BrowserContext.clear_cookies
+    async def to_be_editable(
+        self,
+        *,
+        editable: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_editable
 
-        Clears context cookies.
-        """
+        Ensures the `Locator` points to an editable element.
 
-        try:
-            log_api("=> browser_context.clear_cookies started")
-            result = mapping.from_maybe_impl(await self._impl_obj.clearCookies())
-            log_api("<= browser_context.clear_cookies succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.clear_cookies failed")
-            raise e
+        **Usage**
 
-    async def grant_permissions(
-        self, permissions: typing.List[str], origin: str = None
-    ) -> NoneType:
-        """BrowserContext.grant_permissions
+        ```py
+        from playwright.async_api import expect
 
-        Grants specified permissions to the browser context. Only grants corresponding permissions to the given origin if
-        specified.
+        locator = page.get_by_role(\"textbox\")
+        await expect(locator).to_be_editable()
+        ```
 
         Parameters
         ----------
-        permissions : List[str]
-            A permission or an array of permissions to grant. Permissions can be one of the following values:
-             - `'geolocation'`
-             - `'midi'`
-             - `'midi-sysex'` (system-exclusive midi)
-             - `'notifications'`
-             - `'push'`
-             - `'camera'`
-             - `'microphone'`
-             - `'background-sync'`
-             - `'ambient-light-sensor'`
-             - `'accelerometer'`
-             - `'gyroscope'`
-             - `'magnetometer'`
-             - `'accessibility-events'`
-             - `'clipboard-read'`
-             - `'clipboard-write'`
-             - `'payment-handler'`
-        origin : Optional[str]
-            The origin to grant permissions to, e.g. "https://example.com".
-        """
-
-        try:
-            log_api("=> browser_context.grant_permissions started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.grantPermissions(
-                    permissions=permissions, origin=origin
-                )
-            )
-            log_api("<= browser_context.grant_permissions succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.grant_permissions failed")
-            raise e
-
-    async def clear_permissions(self) -> NoneType:
-        """BrowserContext.clear_permissions
-
-        Clears all permission overrides for the browser context.
+        editable : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.clear_permissions started")
-            result = mapping.from_maybe_impl(await self._impl_obj.clearPermissions())
-            log_api("<= browser_context.clear_permissions succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.clear_permissions failed")
-            raise e
-
-    async def set_geolocation(
-        self, latitude: float, longitude: float, accuracy: float = None
-    ) -> NoneType:
-        """BrowserContext.set_geolocation
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_be_editable(
+                editable=editable, timeout=to_milliseconds(timeout)
+            )
+        )
 
-        Sets the context's geolocation. Passing `null` or `undefined` emulates position unavailable.
+    async def not_to_be_editable(
+        self,
+        *,
+        editable: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_editable
 
-        **NOTE** Consider using browser_context.grant_permissions(permissions[, options]) to grant permissions for the browser context pages to
-        read its geolocation.
+        The opposite of `locator_assertions.to_be_editable()`.
 
         Parameters
         ----------
-        latitude : float
-            Latitude between -90 and 90. **required**
-        longitude : float
-            Longitude between -180 and 180. **required**
-        accuracy : Optional[float]
-            Non-negative accuracy value. Defaults to `0`.
+        editable : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.set_geolocation started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.setGeolocation(
-                    latitude=latitude, longitude=longitude, accuracy=accuracy
-                )
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_be_editable(
+                editable=editable, timeout=to_milliseconds(timeout)
             )
-            log_api("<= browser_context.set_geolocation succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.set_geolocation failed")
-            raise e
+        )
 
-    async def reset_geolocation(self) -> NoneType:
+    async def to_be_empty(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_empty
 
-        try:
-            log_api("=> browser_context.reset_geolocation started")
-            result = mapping.from_maybe_impl(await self._impl_obj.resetGeolocation())
-            log_api("<= browser_context.reset_geolocation succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.reset_geolocation failed")
-            raise e
-
-    async def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneType:
-        """BrowserContext.set_extra_http_headers
+        Ensures the `Locator` points to an empty editable element or to a DOM node that has no text.
+
+        **Usage**
 
-        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.set_extra_http_headers(headers). If page overrides a particular header,
-        page-specific header value will be used instead of the browser context header value.
+        ```py
+        from playwright.async_api import expect
 
-        **NOTE** `browser_context.set_extra_http_headers` does not guarantee the order of headers in the outgoing requests.
+        locator = page.locator(\"div.warning\")
+        await expect(locator).to_be_empty()
+        ```
 
         Parameters
         ----------
-        headers : Dict[str, str]
-            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.set_extra_http_headers started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.setExtraHTTPHeaders(
-                    headers=mapping.to_impl(headers)
-                )
-            )
-            log_api("<= browser_context.set_extra_http_headers succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.set_extra_http_headers failed")
-            raise e
-
-    async def set_offline(self, offline: bool) -> NoneType:
-        """BrowserContext.set_offline
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_be_empty(timeout=to_milliseconds(timeout))
+        )
+
+    async def not_to_be_empty(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_empty
+
+        The opposite of `locator_assertions.to_be_empty()`.
 
         Parameters
         ----------
-        offline : bool
-            Whether to emulate network being offline for the browser context.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.set_offline started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.setOffline(offline=offline)
-            )
-            log_api("<= browser_context.set_offline succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.set_offline failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_be_empty(timeout=to_milliseconds(timeout))
+        )
 
-    async def add_init_script(
-        self, source: str = None, path: typing.Union[str, pathlib.Path] = None
-    ) -> NoneType:
-        """BrowserContext.add_init_script
+    async def to_be_enabled(
+        self,
+        *,
+        enabled: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_enabled
 
-        Adds a script which would be evaluated in one of the following scenarios:
+        Ensures the `Locator` points to an enabled element.
 
-        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.
+        **Usage**
 
-        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`.
-        An example of overriding `Math.random` before the page loads:
+        ```py
+        from playwright.async_api import expect
 
-        **NOTE** The order of evaluation of multiple scripts installed via browser_context.add_init_script(script[, arg]) and
-        page.add_init_script(script[, arg]) is not defined.
+        locator = page.locator(\"button.submit\")
+        await expect(locator).to_be_enabled()
+        ```
 
         Parameters
         ----------
-        source : Optional[str]
-            Script to be evaluated in all pages in the browser context.
+        enabled : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.add_init_script started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.addInitScript(source=source, path=path)
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_be_enabled(
+                enabled=enabled, timeout=to_milliseconds(timeout)
             )
-            log_api("<= browser_context.add_init_script succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.add_init_script failed")
-            raise e
-
-    async def expose_binding(
-        self, name: str, binding: typing.Callable, handle: bool = None
-    ) -> NoneType:
-        """BrowserContext.expose_binding
+        )
 
-        The method adds a function called `name` on the `window` object of every frame in every page in the context. When
-        called, the function executes `playwrightBinding` in Node.js and returns a Promise which resolves to the return value
-        of `playwrightBinding`. If the `playwrightBinding` returns a Promise, it will be awaited.
-        The first argument of the `playwrightBinding` function contains information about the caller: `{ browserContext: BrowserContext, page: Page, frame: Frame }`.
-        See page.expose_binding(name, playwrightBinding[, options]) for page-only version.
-        An example of exposing page URL to all frames in all pages in the context:
+    async def not_to_be_enabled(
+        self,
+        *,
+        enabled: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_enabled
 
-        An example of passing an element handle:
+        The opposite of `locator_assertions.to_be_enabled()`.
 
         Parameters
         ----------
-        name : str
-            Name of the function on the window object.
-        binding : Callable
-            Callback function that will be called in the Playwright's context.
-        handle : Optional[bool]
-            Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is supported. When passing by value, multiple arguments are supported.
+        enabled : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.expose_binding started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.exposeBinding(
-                    name=name, binding=self._wrap_handler(binding), handle=handle
-                )
-            )
-            log_api("<= browser_context.expose_binding succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.expose_binding failed")
-            raise e
-
-    async def expose_function(self, name: str, binding: typing.Callable) -> NoneType:
-        """BrowserContext.expose_function
-
-        The method adds a function called `name` on the `window` object of every frame in every page in the context. When
-        called, the function executes `playwrightFunction` in Node.js and returns a Promise which resolves to the return value
-        of `playwrightFunction`.
-        If the `playwrightFunction` returns a Promise, it will be awaited.
-        See page.expose_function(name, playwrightFunction) for page-only version.
-        An example of adding an `md5` function to all pages in the context:
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_be_enabled(
+                enabled=enabled, timeout=to_milliseconds(timeout)
+            )
+        )
 
-        Parameters
-        ----------
-        name : str
-            Name of the function on the window object.
-        binding : Callable
-            Callback function that will be called in the Playwright's context.
-        """
+    async def to_be_hidden(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_hidden
 
-        try:
-            log_api("=> browser_context.expose_function started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.exposeFunction(
-                    name=name, binding=self._wrap_handler(binding)
-                )
-            )
-            log_api("<= browser_context.expose_function succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.expose_function failed")
-            raise e
+        Ensures that `Locator` either does not resolve to any DOM node, or resolves to a
+        [non-visible](https://playwright.dev/python/docs/actionability#visible) one.
 
-    async def route(
-        self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]],
-        handler: typing.Union[
-            typing.Callable[["Route"], typing.Any],
-            typing.Callable[["Route", "Request"], typing.Any],
-        ],
-    ) -> NoneType:
-        """BrowserContext.route
+        **Usage**
 
-        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.
-        An example of a naïve handler that aborts all image requests:
-        or the same snippet using a regex pattern instead:
-        Page routes (set up with page.route(url, handler)) take precedence over browser context routes when request matches both
-        handlers.
+        ```py
+        from playwright.async_api import expect
 
-        **NOTE** Enabling routing disables http cache.
+        locator = page.locator('.my-element')
+        await expect(locator).to_be_hidden()
+        ```
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool]]
-            A glob pattern, regex pattern or predicate receiving URL to match while routing.
-        handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any]]
-            handler function to route the request.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.route started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.route(
-                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
-                )
-            )
-            log_api("<= browser_context.route succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.route failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_be_hidden(timeout=to_milliseconds(timeout))
+        )
 
-    async def unroute(
+    async def not_to_be_hidden(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]],
-        handler: typing.Union[
-            typing.Callable[["Route"], typing.Any],
-            typing.Callable[["Route", "Request"], typing.Any],
-        ] = None,
-    ) -> NoneType:
-        """BrowserContext.unroute
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_hidden
 
-        Removes a route created with browser_context.route(url, handler). When `handler` is not specified, removes all routes for the
-        `url`.
+        The opposite of `locator_assertions.to_be_hidden()`.
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool]]
-            A glob pattern, regex pattern or predicate receiving URL used to register a routing with browser_context.route(url, handler).
-        handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any], NoneType]
-            Optional handler function used to register a routing with browser_context.route(url, handler).
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.unroute started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.unroute(
-                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
-                )
-            )
-            log_api("<= browser_context.unroute succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.unroute failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_be_hidden(timeout=to_milliseconds(timeout))
+        )
 
-    async def wait_for_event(
+    async def to_be_visible(
         self,
-        event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
-    ) -> typing.Any:
-        """BrowserContext.wait_for_event
+        *,
+        visible: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_visible
 
-        Waits for event to fire and passes its value into the predicate function. Resolves when the predicate returns truthy
-        value. Will throw an error if the context closes before the event is fired. Returns the event data value.
+        Ensures that `Locator` points to an attached and [visible](https://playwright.dev/python/docs/actionability#visible) DOM node.
 
-        Parameters
-        ----------
-        event : str
-            Event name, same one would pass into `browserContext.on(event)`.
+        To check that at least one element from the list is visible, use `locator.first()`.
 
-        Returns
-        -------
-        Any
-        """
+        **Usage**
 
-        try:
-            log_api("=> browser_context.wait_for_event started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.waitForEvent(
-                    event=event,
-                    predicate=self._wrap_handler(predicate),
-                    timeout=timeout,
-                )
-            )
-            log_api("<= browser_context.wait_for_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.wait_for_event failed")
-            raise e
-
-    async def close(self) -> NoneType:
-        """BrowserContext.close
+        ```py
+        # A specific element is visible.
+        await expect(page.get_by_text(\"Welcome\")).to_be_visible()
 
-        Closes the browser context. All the pages that belong to the browser context will be closed.
+        # At least one item in the list is visible.
+        await expect(page.get_by_test_id(\"todo-item\").first).to_be_visible()
+
+        # At least one of the two elements is visible, possibly both.
+        await expect(
+            page.get_by_role(\"button\", name=\"Sign in\")
+            .or_(page.get_by_role(\"button\", name=\"Sign up\"))
+            .first
+        ).to_be_visible()
+        ```
 
-        **NOTE** the default browser context cannot be closed.
+        Parameters
+        ----------
+        visible : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.close started")
-            result = mapping.from_maybe_impl(await self._impl_obj.close())
-            log_api("<= browser_context.close succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.close failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_be_visible(
+                visible=visible, timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def storage_state(
-        self, path: typing.Union[str, pathlib.Path] = None
-    ) -> "StorageState":
-        """BrowserContext.storage_state
+    async def not_to_be_visible(
+        self,
+        *,
+        visible: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_visible
 
-        Returns storage state for this browser context, contains current cookies and local storage snapshot.
+        The opposite of `locator_assertions.to_be_visible()`.
 
         Parameters
         ----------
-        path : Union[str, pathlib.Path, NoneType]
-            The file path to save the storage state to. If `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.
-
-        Returns
-        -------
-        {"cookies": Optional[List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]], "origins": Optional[List[Dict]]}
+        visible : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.storage_state started")
-            result = mapping.from_impl(await self._impl_obj.storageState(path=path))
-            log_api("<= browser_context.storage_state succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.storage_state failed")
-            raise e
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_be_visible(
+                visible=visible, timeout=to_milliseconds(timeout)
+            )
+        )
 
-    def expect_event(
+    async def to_be_focused(
         self,
-        event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager:
-        """BrowserContext.expect_event
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_focused
+
+        Ensures the `Locator` points to a focused DOM node.
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        **Usage**
 
-        async with page.expect_event() as event_info:
-            await page.click("button")
-        value = event_info.value
+        ```py
+        from playwright.async_api import expect
+
+        locator = page.get_by_role(\"textbox\")
+        await expect(locator).to_be_focused()
+        ```
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        return AsyncEventContextManager(
-            self._impl_obj.waitForEvent(event, predicate, timeout)
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_be_focused(timeout=to_milliseconds(timeout))
         )
 
-    def expect_page(
+    async def not_to_be_focused(
         self,
-        predicate: typing.Union[typing.Callable[["Page"], bool]] = None,
-        timeout: int = None,
-    ) -> AsyncEventContextManager["Page"]:
-        """BrowserContext.expect_page
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_focused
 
-        async with page.expect_page() as event_info:
-            await page.click("button")
-        value = event_info.value
+        The opposite of `locator_assertions.to_be_focused()`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        event = "page"
-        return AsyncEventContextManager(
-            self._impl_obj.waitForEvent(event, predicate, timeout)
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_be_focused(timeout=to_milliseconds(timeout))
         )
 
+    async def to_be_in_viewport(
+        self,
+        *,
+        ratio: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_in_viewport
+
+        Ensures the `Locator` points to an element that intersects viewport, according to the
+        [intersection observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API).
+
+        **Usage**
+
+        ```py
+        from playwright.async_api import expect
+
+        locator = page.get_by_role(\"button\")
+        # Make sure at least some part of element intersects viewport.
+        await expect(locator).to_be_in_viewport()
+        # Make sure element is fully outside of viewport.
+        await expect(locator).not_to_be_in_viewport()
+        # Make sure that at least half of the element intersects viewport.
+        await expect(locator).to_be_in_viewport(ratio=0.5)
+        ```
 
-mapping.register(BrowserContextImpl, BrowserContext)
+        Parameters
+        ----------
+        ratio : Union[float, None]
+            The minimal ratio of the element to intersect viewport. If equals to `0`, then element should intersect viewport at
+            any positive ratio. Defaults to `0`.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
 
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_be_in_viewport(
+                ratio=ratio, timeout=to_milliseconds(timeout)
+            )
+        )
 
-class CDPSession(AsyncBase):
-    def __init__(self, obj: CDPSessionImpl):
-        super().__init__(obj)
+    async def not_to_be_in_viewport(
+        self,
+        *,
+        ratio: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_in_viewport
 
-    async def send(self, method: str, params: typing.Dict = None) -> typing.Dict:
-        """CDPSession.send
+        The opposite of `locator_assertions.to_be_in_viewport()`.
 
         Parameters
         ----------
-        method : str
-            protocol method name
-        params : Optional[Dict]
-            Optional method parameters
-
-        Returns
-        -------
-        Dict
+        ratio : Union[float, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> cdp_session.send started")
-            result = mapping.from_maybe_impl(
-                await self._impl_obj.send(method=method, params=mapping.to_impl(params))
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_be_in_viewport(
+                ratio=ratio, timeout=to_milliseconds(timeout)
             )
-            log_api("<= cdp_session.send succeded")
-            return result
-        except Exception as e:
-            log_api("<= cdp_session.send failed")
-            raise e
-
-    async def detach(self) -> NoneType:
-        """CDPSession.detach
-
-        Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be used to
-        send messages.
-        """
+        )
 
-        try:
-            log_api("=> cdp_session.detach started")
-            result = mapping.from_maybe_impl(await self._impl_obj.detach())
-            log_api("<= cdp_session.detach succeded")
-            return result
-        except Exception as e:
-            log_api("<= cdp_session.detach failed")
-            raise e
+    async def to_have_accessible_description(
+        self,
+        description: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_description
 
+        Ensures the `Locator` points to an element with a given
+        [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
 
-mapping.register(CDPSessionImpl, CDPSession)
+        **Usage**
 
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        await expect(locator).to_have_accessible_description(\"Save results to disk\")
+        ```
 
-class ChromiumBrowserContext(BrowserContext):
-    def __init__(self, obj: ChromiumBrowserContextImpl):
-        super().__init__(obj)
+        Parameters
+        ----------
+        description : Union[Pattern[str], str]
+            Expected accessible description.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_accessible_description(
+                description=description,
+                ignoreCase=ignore_case,
+                timeout=to_milliseconds(timeout),
+            )
+        )
 
-    def background_pages(self) -> typing.List["Page"]:
-        """ChromiumBrowserContext.background_pages
+    async def not_to_have_accessible_description(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_description
 
-        All existing background pages in the context.
+        The opposite of `locator_assertions.to_have_accessible_description()`.
 
-        Returns
-        -------
-        List[Page]
-        """
+        Parameters
+        ----------
+        name : Union[Pattern[str], str]
+            Expected accessible description.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_accessible_description(
+                name=name, ignoreCase=ignore_case, timeout=to_milliseconds(timeout)
+            )
+        )
 
-        try:
-            log_api("=> chromium_browser_context.background_pages started")
-            result = mapping.from_impl_list(self._impl_obj.backgroundPages())
-            log_api("<= chromium_browser_context.background_pages succeded")
-            return result
-        except Exception as e:
-            log_api("<= chromium_browser_context.background_pages failed")
-            raise e
+    async def to_have_accessible_name(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_name
 
-    def service_workers(self) -> typing.List["Worker"]:
-        """ChromiumBrowserContext.service_workers
+        Ensures the `Locator` points to an element with a given
+        [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
 
-        All existing service workers in the context.
+        **Usage**
 
-        Returns
-        -------
-        List[Worker]
-        """
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        await expect(locator).to_have_accessible_name(\"Save to disk\")
+        ```
 
-        try:
-            log_api("=> chromium_browser_context.service_workers started")
-            result = mapping.from_impl_list(self._impl_obj.serviceWorkers())
-            log_api("<= chromium_browser_context.service_workers succeded")
-            return result
-        except Exception as e:
-            log_api("<= chromium_browser_context.service_workers failed")
-            raise e
+        Parameters
+        ----------
+        name : Union[Pattern[str], str]
+            Expected accessible name.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_accessible_name(
+                name=name, ignoreCase=ignore_case, timeout=to_milliseconds(timeout)
+            )
+        )
 
-    async def new_cdp_session(self, page: "Page") -> "CDPSession":
-        """ChromiumBrowserContext.new_cdp_session
+    async def not_to_have_accessible_name(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_name
 
-        Returns the newly created session.
+        The opposite of `locator_assertions.to_have_accessible_name()`.
 
         Parameters
         ----------
-        page : Page
-            Page to create new session for.
-
-        Returns
-        -------
-        CDPSession
-        """
-
-        try:
-            log_api("=> chromium_browser_context.new_cdp_session started")
-            result = mapping.from_impl(
-                await self._impl_obj.newCDPSession(page=page._impl_obj)
+        name : Union[Pattern[str], str]
+            Expected accessible name.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_accessible_name(
+                name=name, ignoreCase=ignore_case, timeout=to_milliseconds(timeout)
             )
-            log_api("<= chromium_browser_context.new_cdp_session succeded")
-            return result
-        except Exception as e:
-            log_api("<= chromium_browser_context.new_cdp_session failed")
-            raise e
-
+        )
 
-mapping.register(ChromiumBrowserContextImpl, ChromiumBrowserContext)
+    async def to_have_role(
+        self,
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_role
 
+        Ensures the `Locator` points to an element with a given [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles).
 
-class Browser(AsyncBase):
-    def __init__(self, obj: BrowserImpl):
-        super().__init__(obj)
+        Note that role is matched as a string, disregarding the ARIA role hierarchy. For example, asserting  a superclass
+        role `\"checkbox\"` on an element with a subclass role `\"switch\"` will fail.
 
-    @property
-    def contexts(self) -> typing.List["BrowserContext"]:
-        """Browser.contexts
+        **Usage**
 
-        Returns an array of all open browser contexts. In a newly created browser, this will return zero browser contexts.
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        await expect(locator).to_have_role(\"button\")
+        ```
 
-        Returns
-        -------
-        List[BrowserContext]
+        Parameters
+        ----------
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        return mapping.from_impl_list(self._impl_obj.contexts)
-
-    @property
-    def version(self) -> str:
-        """Browser.version
+        __tracebackhide__ = True
 
-        Returns the browser version.
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_role(
+                role=role, timeout=to_milliseconds(timeout)
+            )
+        )
 
-        Returns
-        -------
-        str
-        """
-        return mapping.from_maybe_impl(self._impl_obj.version)
+    async def to_have_accessible_error_message(
+        self,
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_error_message
 
-    def is_connected(self) -> bool:
-        """Browser.is_connected
+        Ensures the `Locator` points to an element with a given
+        [aria errormessage](https://w3c.github.io/aria/#aria-errormessage).
 
-        Indicates that the browser is connected.
+        **Usage**
 
-        Returns
-        -------
-        bool
-        """
+        ```py
+        locator = page.get_by_test_id(\"username-input\")
+        await expect(locator).to_have_accessible_error_message(\"Username is required.\")
+        ```
 
-        try:
-            log_api("=> browser.is_connected started")
-            result = mapping.from_maybe_impl(self._impl_obj.isConnected())
-            log_api("<= browser.is_connected succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser.is_connected failed")
-            raise e
+        Parameters
+        ----------
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_have_accessible_error_message(
+                errorMessage=error_message,
+                ignoreCase=ignore_case,
+                timeout=to_milliseconds(timeout),
+            )
+        )
 
-    async def new_context(
+    async def not_to_have_accessible_error_message(
         self,
-        viewport: typing.Union[typing.Tuple[int, int], Literal[0]] = None,
-        ignore_https_errors: bool = None,
-        java_script_enabled: bool = None,
-        bypass_csp: bool = None,
-        user_agent: str = None,
-        locale: str = None,
-        timezone_id: str = None,
-        geolocation: "Geolocation" = None,
-        permissions: typing.List[str] = None,
-        extra_http_headers: typing.Union[typing.Dict[str, str]] = None,
-        offline: bool = None,
-        http_credentials: typing.Union[typing.Tuple[str, str]] = None,
-        device_scale_factor: int = None,
-        is_mobile: bool = None,
-        has_touch: bool = None,
-        color_scheme: Literal["dark", "light", "no-preference"] = None,
-        accept_downloads: bool = None,
-        default_browser_type: str = None,
-        proxy: "ProxySettings" = None,
-        record_har_path: typing.Union[str, pathlib.Path] = None,
-        record_har_omit_content: bool = None,
-        record_video_dir: typing.Union[str, pathlib.Path] = None,
-        record_video_size: typing.Union[typing.Tuple[int, int]] = None,
-        storage_state: typing.Union["StorageState", str, pathlib.Path] = None,
-    ) -> "BrowserContext":
-        """Browser.new_context
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_error_message
 
-        Creates a new browser context. It won't share cookies/cache with other browser contexts.
+        The opposite of `locator_assertions.to_have_accessible_error_message()`.
 
         Parameters
         ----------
-        viewport : Union[typing.Tuple[int, int], '0', NoneType]
-            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `null` disables the default viewport.
-        ignore_https_errors : Optional[bool]
-            Whether to ignore HTTPS errors during navigation. Defaults to `false`.
-        java_script_enabled : Optional[bool]
-            Whether or not to enable JavaScript in the context. Defaults to `true`.
-        bypass_csp : Optional[bool]
-            Toggles bypassing page's Content-Security-Policy.
-        user_agent : Optional[str]
-            Specific user agent to use in this context.
-        locale : Optional[str]
-            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.
-        timezone_id : Optional[str]
-            Changes the timezone of the context. See ICU’s `metaZones.txt` for a list of supported timezone IDs.
-        geolocation : Optional[{"latitude": float, "longitude": float, "accuracy": Optional[float]}]
-        permissions : Optional[List[str]]
-            A list of permissions to grant to all pages in this context. See browserContext.grantPermissions(permissions[, options]) for more details.
-        extra_http_headers : Optional[Dict[str, str]]
-            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
-        offline : Optional[bool]
-            Whether to emulate network being offline. Defaults to `false`.
-        http_credentials : Optional[typing.Tuple[str, str]]
-            Credentials for HTTP authentication.
-        device_scale_factor : Optional[int]
-            Specify device scale factor (can be thought of as dpr). Defaults to `1`.
-        is_mobile : Optional[bool]
-            Whether the `meta viewport` tag is taken into account and touch events are enabled. Defaults to `false`. Not supported in Firefox.
-        has_touch : Optional[bool]
-            Specifies if viewport supports touch events. Defaults to false.
-        color_scheme : Optional[Literal['dark', 'light', 'no-preference']]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See page.emulateMedia(params) for more details. Defaults to '`light`'.
-        accept_downloads : Optional[bool]
-            Whether to automatically download all the attachments. Defaults to `false` where all the downloads are canceled.
-        proxy : Optional[{"server": str, "bypass": Optional[str], "username": Optional[str], "password": Optional[str]}]
-            Network proxy settings to use with this context. Note that browser needs to be launched with the global proxy for this option to work. If all contexts override the proxy, global proxy will be never used and can be any string, for example `launch({ proxy: { server: 'per-context' } })`.
-        record_har_path : Union[str, pathlib.Path, NoneType]
-            Path on the filesystem to write the HAR file to.
-        record_har_omit_content : Optional[bool]
-            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
-        record_video_dir : Union[str, pathlib.Path, NoneType]
-            Path to the directory to put videos into.
-        record_video_size : Optional[typing.Tuple[int, int]]
-            Optional dimensions of the recorded videos. If not specified the size will be equal to `viewport`. If `viewport` is not configured explicitly the video size defaults to 1280x720. Actual picture of each page will be scaled down if necessary to fit the specified size.
-        storage_state : Union[{"cookies": Optional[List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]], "origins": Optional[List[Dict]]}, str, pathlib.Path, NoneType]
-            Populates context with given storage state. This method can be used to initialize context with logged-in information obtained via browserContext.storageState([options]). Either a path to the file with saved storage, or an object with the following fields:
-
-        Returns
-        -------
-        BrowserContext
-        """
-
-        try:
-            log_api("=> browser.new_context started")
-            result = mapping.from_impl(
-                await self._impl_obj.newContext(
-                    viewport=viewport,
-                    ignoreHTTPSErrors=ignore_https_errors,
-                    javaScriptEnabled=java_script_enabled,
-                    bypassCSP=bypass_csp,
-                    userAgent=user_agent,
-                    locale=locale,
-                    timezoneId=timezone_id,
-                    geolocation=geolocation,
-                    permissions=permissions,
-                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                    offline=offline,
-                    httpCredentials=http_credentials,
-                    deviceScaleFactor=device_scale_factor,
-                    isMobile=is_mobile,
-                    hasTouch=has_touch,
-                    colorScheme=color_scheme,
-                    acceptDownloads=accept_downloads,
-                    defaultBrowserType=default_browser_type,
-                    proxy=proxy,
-                    recordHarPath=record_har_path,
-                    recordHarOmitContent=record_har_omit_content,
-                    recordVideoDir=record_video_dir,
-                    recordVideoSize=record_video_size,
-                    storageState=storage_state,
-                )
-            )
-            log_api("<= browser.new_context succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser.new_context failed")
-            raise e
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_accessible_error_message(
+                errorMessage=error_message,
+                ignoreCase=ignore_case,
+                timeout=to_milliseconds(timeout),
+            )
+        )
 
-    async def new_page(
+    async def not_to_have_role(
         self,
-        viewport: typing.Union[typing.Tuple[int, int], Literal[0]] = None,
-        ignore_https_errors: bool = None,
-        java_script_enabled: bool = None,
-        bypass_csp: bool = None,
-        user_agent: str = None,
-        locale: str = None,
-        timezone_id: str = None,
-        geolocation: "Geolocation" = None,
-        permissions: typing.List[str] = None,
-        extra_http_headers: typing.Union[typing.Dict[str, str]] = None,
-        offline: bool = None,
-        http_credentials: typing.Union[typing.Tuple[str, str]] = None,
-        device_scale_factor: int = None,
-        is_mobile: bool = None,
-        has_touch: bool = None,
-        color_scheme: Literal["dark", "light", "no-preference"] = None,
-        accept_downloads: bool = None,
-        default_browser_type: str = None,
-        proxy: "ProxySettings" = None,
-        record_har_path: typing.Union[str, pathlib.Path] = None,
-        record_har_omit_content: bool = None,
-        record_video_dir: typing.Union[str, pathlib.Path] = None,
-        record_video_size: typing.Union[typing.Tuple[int, int]] = None,
-        storage_state: typing.Union["StorageState", str, pathlib.Path] = None,
-    ) -> "Page":
-        """Browser.new_page
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_role
 
-        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.new_context([options]) followed by the browser_context.new_page() to
-        control their exact life times.
+        The opposite of `locator_assertions.to_have_role()`.
 
         Parameters
         ----------
-        viewport : Union[typing.Tuple[int, int], '0', NoneType]
-            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `null` disables the default viewport.
-        ignore_https_errors : Optional[bool]
-            Whether to ignore HTTPS errors during navigation. Defaults to `false`.
-        java_script_enabled : Optional[bool]
-            Whether or not to enable JavaScript in the context. Defaults to `true`.
-        bypass_csp : Optional[bool]
-            Toggles bypassing page's Content-Security-Policy.
-        user_agent : Optional[str]
-            Specific user agent to use in this context.
-        locale : Optional[str]
-            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.
-        timezone_id : Optional[str]
-            Changes the timezone of the context. See ICU’s `metaZones.txt` for a list of supported timezone IDs.
-        geolocation : Optional[{"latitude": float, "longitude": float, "accuracy": Optional[float]}]
-        permissions : Optional[List[str]]
-            A list of permissions to grant to all pages in this context. See browserContext.grantPermissions(permissions[, options]) for more details.
-        extra_http_headers : Optional[Dict[str, str]]
-            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
-        offline : Optional[bool]
-            Whether to emulate network being offline. Defaults to `false`.
-        http_credentials : Optional[typing.Tuple[str, str]]
-            Credentials for HTTP authentication.
-        device_scale_factor : Optional[int]
-            Specify device scale factor (can be thought of as dpr). Defaults to `1`.
-        is_mobile : Optional[bool]
-            Whether the `meta viewport` tag is taken into account and touch events are enabled. Defaults to `false`. Not supported in Firefox.
-        has_touch : Optional[bool]
-            Specifies if viewport supports touch events. Defaults to false.
-        color_scheme : Optional[Literal['dark', 'light', 'no-preference']]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See page.emulateMedia(params) for more details. Defaults to '`light`'.
-        accept_downloads : Optional[bool]
-            Whether to automatically download all the attachments. Defaults to `false` where all the downloads are canceled.
-        proxy : Optional[{"server": str, "bypass": Optional[str], "username": Optional[str], "password": Optional[str]}]
-            Network proxy settings to use with this context. Note that browser needs to be launched with the global proxy for this option to work. If all contexts override the proxy, global proxy will be never used and can be any string, for example `launch({ proxy: { server: 'per-context' } })`.
-        record_har_path : Union[str, pathlib.Path, NoneType]
-            Path on the filesystem to write the HAR file to.
-        record_har_omit_content : Optional[bool]
-            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
-        record_video_dir : Union[str, pathlib.Path, NoneType]
-            Path to the directory to put videos into.
-        record_video_size : Optional[typing.Tuple[int, int]]
-            Optional dimensions of the recorded videos. If not specified the size will be equal to `viewport`. If `viewport` is not configured explicitly the video size defaults to 1280x720. Actual picture of each page will be scaled down if necessary to fit the specified size.
-        storage_state : Union[{"cookies": Optional[List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]], "origins": Optional[List[Dict]]}, str, pathlib.Path, NoneType]
-            Populates context with given storage state. This method can be used to initialize context with logged-in information obtained via browserContext.storageState([options]). Either a path to the file with saved storage, or an object with the following fields:
-
-        Returns
-        -------
-        Page
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser.new_page started")
-            result = mapping.from_impl(
-                await self._impl_obj.newPage(
-                    viewport=viewport,
-                    ignoreHTTPSErrors=ignore_https_errors,
-                    javaScriptEnabled=java_script_enabled,
-                    bypassCSP=bypass_csp,
-                    userAgent=user_agent,
-                    locale=locale,
-                    timezoneId=timezone_id,
-                    geolocation=geolocation,
-                    permissions=permissions,
-                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                    offline=offline,
-                    httpCredentials=http_credentials,
-                    deviceScaleFactor=device_scale_factor,
-                    isMobile=is_mobile,
-                    hasTouch=has_touch,
-                    colorScheme=color_scheme,
-                    acceptDownloads=accept_downloads,
-                    defaultBrowserType=default_browser_type,
-                    proxy=proxy,
-                    recordHarPath=record_har_path,
-                    recordHarOmitContent=record_har_omit_content,
-                    recordVideoDir=record_video_dir,
-                    recordVideoSize=record_video_size,
-                    storageState=storage_state,
-                )
-            )
-            log_api("<= browser.new_page succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser.new_page failed")
-            raise e
-
-    async def close(self) -> NoneType:
-        """Browser.close
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_have_role(
+                role=role, timeout=to_milliseconds(timeout)
+            )
+        )
 
-        In case this browser is obtained using browser_type.launch([options]), closes the browser and all of its pages (if any were
-        opened).
-        In case this browser is obtained using browser_type.connect(params), clears all created contexts belonging to this browser
-        and disconnects from the browser server.
-        The Browser object itself is considered to be disposed and cannot be used anymore.
-        """
+    async def to_match_aria_snapshot(
+        self,
+        expected: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_match_aria_snapshot
+
+        Asserts that the target element matches the given [accessibility snapshot](https://playwright.dev/python/docs/aria-snapshots).
+
+        **Usage**
+
+        ```py
+        await page.goto(\"https://demo.playwright.dev/todomvc/\")
+        await expect(page.locator('body')).to_match_aria_snapshot('''
+          - heading \"todos\"
+          - textbox \"What needs to be done?\"
+        ''')
+        ```
 
-        try:
-            log_api("=> browser.close started")
-            result = mapping.from_maybe_impl(await self._impl_obj.close())
-            log_api("<= browser.close succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser.close failed")
-            raise e
+        Parameters
+        ----------
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
 
+        return mapping.from_maybe_impl(
+            await self._impl_obj.to_match_aria_snapshot(
+                expected=expected, timeout=to_milliseconds(timeout)
+            )
+        )
 
-mapping.register(BrowserImpl, Browser)
+    async def not_to_match_aria_snapshot(
+        self,
+        expected: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_match_aria_snapshot
 
+        The opposite of `locator_assertions.to_match_aria_snapshot()`.
 
-class BrowserType(AsyncBase):
-    def __init__(self, obj: BrowserTypeImpl):
-        super().__init__(obj)
+        Parameters
+        ----------
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
 
-    @property
-    def name(self) -> str:
-        """BrowserType.name
+        return mapping.from_maybe_impl(
+            await self._impl_obj.not_to_match_aria_snapshot(
+                expected=expected, timeout=to_milliseconds(timeout)
+            )
+        )
 
-        Returns browser name. For example: `'chromium'`, `'webkit'` or `'firefox'`.
 
-        Returns
-        -------
-        str
-        """
-        return mapping.from_maybe_impl(self._impl_obj.name)
+mapping.register(LocatorAssertionsImpl, LocatorAssertions)
 
-    @property
-    def executable_path(self) -> str:
-        """BrowserType.executable_path
 
-        A path where Playwright expects to find a bundled browser executable.
+class APIResponseAssertions(AsyncBase):
 
-        Returns
-        -------
-        str
-        """
-        return mapping.from_maybe_impl(self._impl_obj.executablePath)
+    async def to_be_ok(self) -> None:
+        """APIResponseAssertions.to_be_ok
 
-    async def launch(
-        self,
-        executable_path: typing.Union[str, pathlib.Path] = None,
-        args: typing.List[str] = None,
-        ignore_default_args: typing.Union[bool, typing.List[str]] = None,
-        handle_sigint: bool = None,
-        handle_sigterm: bool = None,
-        handle_sighup: bool = None,
-        timeout: int = None,
-        env: typing.Union[typing.Dict[str, typing.Union[str, int, bool]]] = None,
-        headless: bool = None,
-        devtools: bool = None,
-        proxy: "ProxySettings" = None,
-        downloads_path: typing.Union[str, pathlib.Path] = None,
-        slow_mo: int = None,
-        chromium_sandbox: bool = None,
-        firefox_user_prefs: typing.Union[
-            typing.Dict[str, typing.Union[str, int, bool]]
-        ] = None,
-    ) -> "Browser":
-        """BrowserType.launch
+        Ensures the response status code is within `200..299` range.
 
-        Returns the browser instance.
-        You can use `ignoreDefaultArgs` to filter out `--mute-audio` from default arguments:
+        **Usage**
 
-        **Chromium-only** Playwright can also be used to control the Chrome browser, 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` option with
-        extreme caution.
-        If Google Chrome (rather than Chromium) is preferred, a Chrome
-        Canary or Dev
-        Channel build is suggested.
-        In browser_type.launch([options]) above, any mention of Chromium also applies to Chrome.
-        See `this article` for
-        a description of the differences between Chromium and Chrome. `This article` describes
-        some differences for Linux users.
-
-        Parameters
-        ----------
-        executable_path : Union[str, pathlib.Path, NoneType]
-            Path to a browser executable to run instead of the bundled one. If `executablePath` is a relative path, then it is resolved relative to current working directory. Note that Playwright only works with the bundled Chromium, Firefox or WebKit, use at your own risk.
-        args : Optional[List[str]]
-            Additional arguments to pass to the browser instance. The list of Chromium flags can be found here.
-        ignore_default_args : Union[bool, List[str], NoneType]
-            If `true`, Playwright does not pass its own configurations args and only uses the ones from `args`. If an array is given, then filters out the given default arguments. Dangerous option; use with care. Defaults to `false`.
-        handle_sigint : Optional[bool]
-            Close the browser process on Ctrl-C. Defaults to `true`.
-        handle_sigterm : Optional[bool]
-            Close the browser process on SIGTERM. Defaults to `true`.
-        handle_sighup : Optional[bool]
-            Close the browser process on SIGHUP. Defaults to `true`.
-        timeout : Optional[int]
-            Maximum time in milliseconds to wait for the browser instance to start. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
-        env : Optional[Dict[str, Union[str, int, bool]]]
-            Specify environment variables that will be visible to the browser. Defaults to `process.env`.
-        headless : Optional[bool]
-            Whether to run browser in headless mode. More details for Chromium and Firefox. Defaults to `true` unless the `devtools` option is `true`.
-        devtools : Optional[bool]
-            **Chromium-only** Whether to auto-open a Developer Tools panel for each tab. If this option is `true`, the `headless` option will be set `false`.
-        proxy : Optional[{"server": str, "bypass": Optional[str], "username": Optional[str], "password": Optional[str]}]
-            Network proxy settings.
-        downloads_path : Union[str, pathlib.Path, NoneType]
-            If specified, accepted downloads are downloaded into this directory. Otherwise, temporary directory is created and is deleted when browser is closed.
-        slow_mo : Optional[int]
-            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going on.
-        chromium_sandbox : Optional[bool]
-            Enable Chromium sandboxing. Defaults to `false`.
-        firefox_user_prefs : Optional[Dict[str, Union[str, int, bool]]]
-            Firefox user preferences. Learn more about the Firefox user preferences at `about:config`.
+        ```py
+        from playwright.async_api import expect
 
-        Returns
-        -------
-        Browser
+        # ...
+        await expect(response).to_be_ok()
+        ```
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_type.launch started")
-            result = mapping.from_impl(
-                await self._impl_obj.launch(
-                    executablePath=executable_path,
-                    args=args,
-                    ignoreDefaultArgs=ignore_default_args,
-                    handleSIGINT=handle_sigint,
-                    handleSIGTERM=handle_sigterm,
-                    handleSIGHUP=handle_sighup,
-                    timeout=timeout,
-                    env=mapping.to_impl(env),
-                    headless=headless,
-                    devtools=devtools,
-                    proxy=proxy,
-                    downloadsPath=downloads_path,
-                    slowMo=slow_mo,
-                    chromiumSandbox=chromium_sandbox,
-                    firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
-                )
-            )
-            log_api("<= browser_type.launch succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_type.launch failed")
-            raise e
-
-    async def launch_persistent_context(
-        self,
-        user_data_dir: typing.Union[str, pathlib.Path],
-        executable_path: typing.Union[str, pathlib.Path] = None,
-        args: typing.List[str] = None,
-        ignore_default_args: typing.Union[bool, typing.List[str]] = None,
-        handle_sigint: bool = None,
-        handle_sigterm: bool = None,
-        handle_sighup: bool = None,
-        timeout: int = None,
-        env: typing.Union[typing.Dict[str, typing.Union[str, int, bool]]] = None,
-        headless: bool = None,
-        devtools: bool = None,
-        proxy: "ProxySettings" = None,
-        downloads_path: typing.Union[str, pathlib.Path] = None,
-        slow_mo: int = None,
-        viewport: typing.Union[typing.Tuple[int, int], Literal[0]] = None,
-        ignore_https_errors: bool = None,
-        java_script_enabled: bool = None,
-        bypass_csp: bool = None,
-        user_agent: str = None,
-        locale: str = None,
-        timezone_id: str = None,
-        geolocation: "Geolocation" = None,
-        permissions: typing.List[str] = None,
-        extra_http_headers: typing.Union[typing.Dict[str, str]] = None,
-        offline: bool = None,
-        http_credentials: typing.Union[typing.Tuple[str, str]] = None,
-        device_scale_factor: int = None,
-        is_mobile: bool = None,
-        has_touch: bool = None,
-        color_scheme: Literal["dark", "light", "no-preference"] = None,
-        accept_downloads: bool = None,
-        chromium_sandbox: bool = None,
-        record_har_path: typing.Union[str, pathlib.Path] = None,
-        record_har_omit_content: bool = None,
-        record_video_dir: typing.Union[str, pathlib.Path] = None,
-        record_video_size: typing.Union[typing.Tuple[int, int]] = None,
-    ) -> "BrowserContext":
-        """BrowserType.launch_persistent_context
-
-        Returns the persistent browser context instance.
-        Launches browser that uses persistent storage located at `userDataDir` and returns the only context. Closing this
-        context will automatically close the browser.
+        return mapping.from_maybe_impl(await self._impl_obj.to_be_ok())
 
-        Parameters
-        ----------
-        user_data_dir : Union[str, pathlib.Path]
-            Path to a User Data Directory, which stores browser session data like cookies and local storage. More details for Chromium and Firefox.
-        executable_path : Union[str, pathlib.Path, NoneType]
-            Path to a browser executable to run instead of the bundled one. If `executablePath` is a relative path, then it is resolved relative to current working directory. **BEWARE**: Playwright is only guaranteed to work with the bundled Chromium, Firefox or WebKit, use at your own risk.
-        args : Optional[List[str]]
-            Additional arguments to pass to the browser instance. The list of Chromium flags can be found here.
-        ignore_default_args : Union[bool, List[str], NoneType]
-            If `true`, then do not use any of the default arguments. If an array is given, then filter out the given default arguments. Dangerous option; use with care. Defaults to `false`.
-        handle_sigint : Optional[bool]
-            Close the browser process on Ctrl-C. Defaults to `true`.
-        handle_sigterm : Optional[bool]
-            Close the browser process on SIGTERM. Defaults to `true`.
-        handle_sighup : Optional[bool]
-            Close the browser process on SIGHUP. Defaults to `true`.
-        timeout : Optional[int]
-            Maximum time in milliseconds to wait for the browser instance to start. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
-        env : Optional[Dict[str, Union[str, int, bool]]]
-            Specify environment variables that will be visible to the browser. Defaults to `process.env`.
-        headless : Optional[bool]
-            Whether to run browser in headless mode. More details for Chromium and Firefox. Defaults to `true` unless the `devtools` option is `true`.
-        devtools : Optional[bool]
-            **Chromium-only** Whether to auto-open a Developer Tools panel for each tab. If this option is `true`, the `headless` option will be set `false`.
-        proxy : Optional[{"server": str, "bypass": Optional[str], "username": Optional[str], "password": Optional[str]}]
-            Network proxy settings.
-        downloads_path : Union[str, pathlib.Path, NoneType]
-            If specified, accepted downloads are downloaded into this directory. Otherwise, temporary directory is created and is deleted when browser is closed.
-        slow_mo : Optional[int]
-            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going on. Defaults to 0.
-        viewport : Union[typing.Tuple[int, int], '0', NoneType]
-            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `null` disables the default viewport.
-        ignore_https_errors : Optional[bool]
-            Whether to ignore HTTPS errors during navigation. Defaults to `false`.
-        java_script_enabled : Optional[bool]
-            Whether or not to enable JavaScript in the context. Defaults to `true`.
-        bypass_csp : Optional[bool]
-            Toggles bypassing page's Content-Security-Policy.
-        user_agent : Optional[str]
-            Specific user agent to use in this context.
-        locale : Optional[str]
-            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.
-        timezone_id : Optional[str]
-            Changes the timezone of the context. See ICU’s `metaZones.txt` for a list of supported timezone IDs.
-        geolocation : Optional[{"latitude": float, "longitude": float, "accuracy": Optional[float]}]
-        permissions : Optional[List[str]]
-            A list of permissions to grant to all pages in this context. See browserContext.grantPermissions(permissions[, options]) for more details.
-        extra_http_headers : Optional[Dict[str, str]]
-            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
-        offline : Optional[bool]
-            Whether to emulate network being offline. Defaults to `false`.
-        http_credentials : Optional[typing.Tuple[str, str]]
-            Credentials for HTTP authentication.
-        device_scale_factor : Optional[int]
-            Specify device scale factor (can be thought of as dpr). Defaults to `1`.
-        is_mobile : Optional[bool]
-            Whether the `meta viewport` tag is taken into account and touch events are enabled. Defaults to `false`. Not supported in Firefox.
-        has_touch : Optional[bool]
-            Specifies if viewport supports touch events. Defaults to false.
-        color_scheme : Optional[Literal['dark', 'light', 'no-preference']]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See page.emulateMedia(params) for more details. Defaults to '`light`'.
-        accept_downloads : Optional[bool]
-            Whether to automatically download all the attachments. Defaults to `false` where all the downloads are canceled.
-        chromium_sandbox : Optional[bool]
-            Enable Chromium sandboxing. Defaults to `true`.
-        record_har_path : Union[str, pathlib.Path, NoneType]
-            Path on the filesystem to write the HAR file to.
-        record_har_omit_content : Optional[bool]
-            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
-        record_video_dir : Union[str, pathlib.Path, NoneType]
-            Path to the directory to put videos into.
-        record_video_size : Optional[typing.Tuple[int, int]]
-            Optional dimensions of the recorded videos. If not specified the size will be equal to `viewport`. If `viewport` is not configured explicitly the video size defaults to 1280x720. Actual picture of each page will be scaled down if necessary to fit the specified size.
+    async def not_to_be_ok(self) -> None:
+        """APIResponseAssertions.not_to_be_ok
 
-        Returns
-        -------
-        BrowserContext
+        The opposite of `a_pi_response_assertions.to_be_ok()`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_type.launch_persistent_context started")
-            result = mapping.from_impl(
-                await self._impl_obj.launchPersistentContext(
-                    userDataDir=user_data_dir,
-                    executablePath=executable_path,
-                    args=args,
-                    ignoreDefaultArgs=ignore_default_args,
-                    handleSIGINT=handle_sigint,
-                    handleSIGTERM=handle_sigterm,
-                    handleSIGHUP=handle_sighup,
-                    timeout=timeout,
-                    env=mapping.to_impl(env),
-                    headless=headless,
-                    devtools=devtools,
-                    proxy=proxy,
-                    downloadsPath=downloads_path,
-                    slowMo=slow_mo,
-                    viewport=viewport,
-                    ignoreHTTPSErrors=ignore_https_errors,
-                    javaScriptEnabled=java_script_enabled,
-                    bypassCSP=bypass_csp,
-                    userAgent=user_agent,
-                    locale=locale,
-                    timezoneId=timezone_id,
-                    geolocation=geolocation,
-                    permissions=permissions,
-                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                    offline=offline,
-                    httpCredentials=http_credentials,
-                    deviceScaleFactor=device_scale_factor,
-                    isMobile=is_mobile,
-                    hasTouch=has_touch,
-                    colorScheme=color_scheme,
-                    acceptDownloads=accept_downloads,
-                    chromiumSandbox=chromium_sandbox,
-                    recordHarPath=record_har_path,
-                    recordHarOmitContent=record_har_omit_content,
-                    recordVideoDir=record_video_dir,
-                    recordVideoSize=record_video_size,
-                )
-            )
-            log_api("<= browser_type.launch_persistent_context succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_type.launch_persistent_context failed")
-            raise e
-
-
-mapping.register(BrowserTypeImpl, BrowserType)
+        return mapping.from_maybe_impl(await self._impl_obj.not_to_be_ok())
 
 
-class Playwright(AsyncBase):
-    def __init__(self, obj: PlaywrightImpl):
-        super().__init__(obj)
+mapping.register(APIResponseAssertionsImpl, APIResponseAssertions)
 
-    @property
-    def chromium(self) -> "BrowserType":
-        return mapping.from_impl(self._impl_obj.chromium)
 
-    @property
-    def firefox(self) -> "BrowserType":
-        return mapping.from_impl(self._impl_obj.firefox)
+class Disposable(AsyncContextManager):
 
-    @property
-    def webkit(self) -> "BrowserType":
-        return mapping.from_impl(self._impl_obj.webkit)
+    async def dispose(self) -> None:
+        """Disposable.dispose
 
-    @property
-    def selectors(self) -> "Selectors":
-        return mapping.from_impl(self._impl_obj.selectors)
+        Removes the associated resource. For example, removes the init script installed via `page.add_init_script()`
+        or `browser_context.add_init_script()`.
+        """
 
-    @property
-    def devices(self) -> typing.Dict[str, "DeviceDescriptor"]:
-        return mapping.from_impl_dict(self._impl_obj.devices)
+        return mapping.from_maybe_impl(await self._impl_obj.dispose())
 
-    def stop(self) -> NoneType:
+    async def close(self) -> None:
 
-        try:
-            log_api("=> playwright.stop started")
-            result = mapping.from_maybe_impl(self._impl_obj.stop())
-            log_api("<= playwright.stop succeded")
-            return result
-        except Exception as e:
-            log_api("<= playwright.stop failed")
-            raise e
+        return mapping.from_maybe_impl(await self._impl_obj.close())
 
 
-mapping.register(PlaywrightImpl, Playwright)
+mapping.register(DisposableImpl, Disposable)
diff --git a/playwright/sync_api/__init__.py b/playwright/sync_api/__init__.py
index efa7a9108..5a3c5526d 100644
--- a/playwright/sync_api/__init__.py
+++ b/playwright/sync_api/__init__.py
@@ -18,28 +18,41 @@
 web automation that is ever-green, capable, reliable and fast.
 """
 
+from typing import Any, Optional, Union, overload
+
 import playwright._impl._api_structures
-import playwright._impl._api_types
+import playwright._impl._errors
+import playwright._impl._form_data
 import playwright.sync_api._generated
+from playwright._impl._assertions import (
+    APIResponseAssertions as APIResponseAssertionsImpl,
+)
+from playwright._impl._assertions import LocatorAssertions as LocatorAssertionsImpl
+from playwright._impl._assertions import PageAssertions as PageAssertionsImpl
 from playwright.sync_api._context_manager import PlaywrightContextManager
 from playwright.sync_api._generated import (
-    Accessibility,
-    BindingCall,
+    APIRequest,
+    APIRequestContext,
+    APIResponse,
+    APIResponseAssertions,
     Browser,
     BrowserContext,
     BrowserType,
     CDPSession,
-    ChromiumBrowserContext,
     ConsoleMessage,
     Dialog,
     Download,
     ElementHandle,
     FileChooser,
     Frame,
+    FrameLocator,
     JSHandle,
     Keyboard,
+    Locator,
+    LocatorAssertions,
     Mouse,
     Page,
+    PageAssertions,
     Playwright,
     Request,
     Response,
@@ -47,41 +60,160 @@
     Selectors,
     Touchscreen,
     Video,
+    WebError,
     WebSocket,
+    WebSocketRoute,
     Worker,
 )
 
+ChromiumBrowserContext = BrowserContext
+
 Cookie = playwright._impl._api_structures.Cookie
+FilePayload = playwright._impl._api_structures.FilePayload
+FormData = playwright._impl._form_data.FormData
+FloatRect = playwright._impl._api_structures.FloatRect
+Geolocation = playwright._impl._api_structures.Geolocation
+HttpCredentials = playwright._impl._api_structures.HttpCredentials
+BrowserBindResult = playwright._impl._api_structures.BrowserBindResult
+DebuggerLocation = playwright._impl._api_structures.DebuggerLocation
+DebuggerPausedDetails = playwright._impl._api_structures.DebuggerPausedDetails
+PdfMargins = playwright._impl._api_structures.PdfMargins
+Position = playwright._impl._api_structures.Position
+ProxySettings = playwright._impl._api_structures.ProxySettings
 ResourceTiming = playwright._impl._api_structures.ResourceTiming
+ScreencastFrame = playwright._impl._api_structures.ScreencastFrame
+SourceLocation = playwright._impl._api_structures.SourceLocation
 StorageState = playwright._impl._api_structures.StorageState
+StorageStateCookie = playwright._impl._api_structures.StorageStateCookie
+ViewportSize = playwright._impl._api_structures.ViewportSize
 
-DeviceDescriptor = playwright._impl._api_types.DeviceDescriptor
-Error = playwright._impl._api_types.Error
-FilePayload = playwright._impl._api_types.FilePayload
-FloatRect = playwright._impl._api_types.FloatRect
-Geolocation = playwright._impl._api_types.Geolocation
-PdfMargins = playwright._impl._api_types.PdfMargins
-ProxySettings = playwright._impl._api_types.ProxySettings
-SourceLocation = playwright._impl._api_types.SourceLocation
-TimeoutError = playwright._impl._api_types.TimeoutError
+Error = playwright._impl._errors.Error
+TimeoutError = playwright._impl._errors.TimeoutError
 
 
 def sync_playwright() -> PlaywrightContextManager:
     return PlaywrightContextManager()
 
 
+class Expect:
+    _unset: Any = object()
+
+    def __init__(self) -> None:
+        self._timeout: Optional[float] = None
+
+    def set_options(self, timeout: Optional[float] = _unset) -> None:
+        """
+        This method sets global `expect()` options.
+
+        Args:
+            timeout (float): Timeout value in milliseconds. Default to 5000 milliseconds.
+
+        Returns:
+            None
+        """
+        if timeout is not self._unset:
+            self._timeout = timeout
+
+    @overload
+    def __call__(
+        self, actual: Page, message: Optional[str] = None
+    ) -> PageAssertions: ...
+
+    @overload
+    def __call__(
+        self, actual: Locator, message: Optional[str] = None
+    ) -> LocatorAssertions: ...
+
+    @overload
+    def __call__(
+        self, actual: APIResponse, message: Optional[str] = None
+    ) -> APIResponseAssertions: ...
+
+    def __call__(
+        self, actual: Union[Page, Locator, APIResponse], message: Optional[str] = None
+    ) -> Union[PageAssertions, LocatorAssertions, APIResponseAssertions]:
+        return self._dispatch(actual, message, is_soft=False)
+
+    @overload
+    def soft(self, actual: Page, message: Optional[str] = None) -> PageAssertions: ...
+
+    @overload
+    def soft(
+        self, actual: Locator, message: Optional[str] = None
+    ) -> LocatorAssertions: ...
+
+    @overload
+    def soft(
+        self, actual: APIResponse, message: Optional[str] = None
+    ) -> APIResponseAssertions: ...
+
+    def soft(
+        self, actual: Union[Page, Locator, APIResponse], message: Optional[str] = None
+    ) -> Union[PageAssertions, LocatorAssertions, APIResponseAssertions]:
+        """
+        Creates a [soft assertion](https://playwright.dev/python/docs/test-assertions#soft-assertions).
+        Failing soft assertions do not abort test execution, but mark the test
+        as failed. Multiple failures from the same test are surfaced together
+        at the end of the test.
+
+        Requires the [pytest-playwright](https://pypi.org/project/pytest-playwright/)
+        plugin to establish the per-test scope that collects soft assertion
+        failures.
+        """
+        return self._dispatch(actual, message, is_soft=True)
+
+    def _dispatch(
+        self,
+        actual: Union[Page, Locator, APIResponse],
+        message: Optional[str],
+        is_soft: bool,
+    ) -> Union[PageAssertions, LocatorAssertions, APIResponseAssertions]:
+        if isinstance(actual, Page):
+            return PageAssertions(
+                PageAssertionsImpl(
+                    actual._impl_obj,
+                    self._timeout,
+                    message=message,
+                    is_soft=is_soft,
+                )
+            )
+        elif isinstance(actual, Locator):
+            return LocatorAssertions(
+                LocatorAssertionsImpl(
+                    actual._impl_obj,
+                    self._timeout,
+                    message=message,
+                    is_soft=is_soft,
+                )
+            )
+        elif isinstance(actual, APIResponse):
+            return APIResponseAssertions(
+                APIResponseAssertionsImpl(
+                    actual._impl_obj,
+                    self._timeout,
+                    message=message,
+                    is_soft=is_soft,
+                )
+            )
+        raise ValueError(f"Unsupported type: {type(actual)}")
+
+
+expect = Expect()
+
+
 __all__ = [
-    "sync_playwright",
-    "Accessibility",
-    "BindingCall",
+    "expect",
+    "APIRequest",
+    "APIRequestContext",
+    "APIResponse",
     "Browser",
+    "BrowserBindResult",
     "BrowserContext",
     "BrowserType",
     "CDPSession",
     "ChromiumBrowserContext",
     "ConsoleMessage",
     "Cookie",
-    "DeviceDescriptor",
     "Dialog",
     "Download",
     "ElementHandle",
@@ -89,26 +221,38 @@ def sync_playwright() -> PlaywrightContextManager:
     "FileChooser",
     "FilePayload",
     "FloatRect",
+    "FormData",
     "Frame",
+    "FrameLocator",
     "Geolocation",
+    "HttpCredentials",
     "JSHandle",
     "Keyboard",
+    "Locator",
     "Mouse",
+    "DebuggerLocation",
+    "DebuggerPausedDetails",
     "Page",
     "PdfMargins",
+    "Position",
     "Playwright",
     "ProxySettings",
     "Request",
     "ResourceTiming",
     "Response",
     "Route",
+    "ScreencastFrame",
     "Selectors",
     "SourceLocation",
     "StorageState",
+    "StorageStateCookie",
     "sync_playwright",
     "TimeoutError",
     "Touchscreen",
     "Video",
+    "ViewportSize",
+    "WebError",
     "WebSocket",
+    "WebSocketRoute",
     "Worker",
 ]
diff --git a/playwright/sync_api/_context_manager.py b/playwright/sync_api/_context_manager.py
index 3c0f0d9b8..feb648ca0 100644
--- a/playwright/sync_api/_context_manager.py
+++ b/playwright/sync_api/_context_manager.py
@@ -13,55 +13,69 @@
 # limitations under the License.
 
 import asyncio
-from typing import Any
+from typing import TYPE_CHECKING, Any, Optional, cast
 
 from greenlet import greenlet
 
-from playwright._impl._api_types import Error
-from playwright._impl._connection import Connection
-from playwright._impl._driver import compute_driver_executable
+from playwright._impl._connection import ChannelOwner, Connection
+from playwright._impl._errors import Error
+from playwright._impl._greenlets import MainGreenlet
 from playwright._impl._object_factory import create_remote_object
 from playwright._impl._playwright import Playwright
+from playwright._impl._transport import PipeTransport
 from playwright.sync_api._generated import Playwright as SyncPlaywright
 
+if TYPE_CHECKING:
+    from asyncio.unix_events import AbstractChildWatcher
+
 
 class PlaywrightContextManager:
     def __init__(self) -> None:
         self._playwright: SyncPlaywright
+        self._loop: asyncio.AbstractEventLoop
+        self._own_loop = False
+        self._watcher: Optional[AbstractChildWatcher] = None
+        self._exit_was_called = False
 
     def __enter__(self) -> SyncPlaywright:
+        try:
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            self._loop = asyncio.new_event_loop()
+            self._own_loop = True
+        if self._loop.is_running():
+            raise Error(
+                """It looks like you are using Playwright Sync API inside the asyncio loop.
+Please use the Async API instead."""
+            )
+
+        # Create a new fiber for the protocol dispatcher. It will be pumping events
+        # until the end of times. We will pass control to that fiber every time we
+        # block while waiting for a response.
         def greenlet_main() -> None:
-            loop = None
-            own_loop = None
-            try:
-                loop = asyncio.get_running_loop()
-            except RuntimeError:
-                loop = asyncio.new_event_loop()
-                own_loop = loop
-
-            if loop.is_running():
-                raise Error("Can only run one Playwright at a time.")
-
-            loop.run_until_complete(self._connection.run_as_sync())
+            self._loop.run_until_complete(self._connection.run_as_sync())
 
-            if own_loop:
-                loop.run_until_complete(loop.shutdown_asyncgens())
-                loop.close()
+        dispatcher_fiber = MainGreenlet(greenlet_main)
 
-        dispatcher_fiber = greenlet(greenlet_main)
         self._connection = Connection(
-            dispatcher_fiber, create_remote_object, compute_driver_executable()
+            dispatcher_fiber,
+            create_remote_object,
+            PipeTransport(self._loop),
+            self._loop,
         )
 
         g_self = greenlet.getcurrent()
 
-        def callback_wrapper(playwright_impl: Playwright) -> None:
+        def callback_wrapper(channel_owner: ChannelOwner) -> None:
+            playwright_impl = cast(Playwright, channel_owner)
             self._playwright = SyncPlaywright(playwright_impl)
             g_self.switch()
 
+        # Switch control to the dispatcher, it'll fire an event and pass control to
+        # the calling greenlet.
         self._connection.call_on_object_with_known_name("Playwright", callback_wrapper)
-
         dispatcher_fiber.switch()
+
         playwright = self._playwright
         playwright.stop = self.__exit__  # type: ignore
         return playwright
@@ -70,4 +84,15 @@ def start(self) -> SyncPlaywright:
         return self.__enter__()
 
     def __exit__(self, *args: Any) -> None:
+        if self._exit_was_called:
+            return
+        self._exit_was_called = True
         self._connection.stop_sync()
+        if self._watcher:
+            self._watcher.close()
+        if self._own_loop:
+            tasks = asyncio.all_tasks(self._loop)
+            for t in [t for t in tasks if not (t.done() or t.cancelled())]:
+                t.cancel()
+            self._loop.run_until_complete(self._loop.shutdown_asyncgens())
+            self._loop.close()
diff --git a/playwright/sync_api/_generated.py b/playwright/sync_api/_generated.py
index 25865819a..d2d37baa2 100644
--- a/playwright/sync_api/_generated.py
+++ b/playwright/sync_api/_generated.py
@@ -13,62 +13,90 @@
 # limitations under the License.
 
 
+import datetime
 import pathlib
-import sys
 import typing
-
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import Literal
-else:  # pragma: no cover
-    from typing_extensions import Literal
-
-from playwright._impl._accessibility import Accessibility as AccessibilityImpl
-from playwright._impl._api_structures import Cookie, ResourceTiming, StorageState
-from playwright._impl._api_types import (
-    DeviceDescriptor,
+from typing import Literal
+
+from playwright._impl._api_structures import (
+    BrowserBindResult,
+    ClientCertificate,
+    Cookie,
+    DebuggerLocation,
+    DebuggerPausedDetails,
+    DropPayload,
     FilePayload,
     FloatRect,
     Geolocation,
+    HttpCredentials,
+    NameValue,
     PdfMargins,
+    Position,
     ProxySettings,
+    RemoteAddr,
+    RequestSizes,
+    ResourceTiming,
+    ScreencastFrame,
+    SecurityDetails,
+    SetCookieParam,
     SourceLocation,
+    StorageState,
+    TracingGroupLocation,
+    ViewportSize,
+    WebErrorLocation,
 )
+from playwright._impl._assertions import (
+    APIResponseAssertions as APIResponseAssertionsImpl,
+)
+from playwright._impl._assertions import LocatorAssertions as LocatorAssertionsImpl
+from playwright._impl._assertions import PageAssertions as PageAssertionsImpl
 from playwright._impl._browser import Browser as BrowserImpl
 from playwright._impl._browser_context import BrowserContext as BrowserContextImpl
 from playwright._impl._browser_type import BrowserType as BrowserTypeImpl
 from playwright._impl._cdp_session import CDPSession as CDPSessionImpl
-from playwright._impl._chromium_browser_context import (
-    ChromiumBrowserContext as ChromiumBrowserContextImpl,
-)
+from playwright._impl._clock import Clock as ClockImpl
 from playwright._impl._console_message import ConsoleMessage as ConsoleMessageImpl
+from playwright._impl._debugger import Debugger as DebuggerImpl
 from playwright._impl._dialog import Dialog as DialogImpl
+from playwright._impl._disposable import Disposable as DisposableImpl
 from playwright._impl._download import Download as DownloadImpl
 from playwright._impl._element_handle import ElementHandle as ElementHandleImpl
+from playwright._impl._errors import Error
+from playwright._impl._fetch import APIRequest as APIRequestImpl
+from playwright._impl._fetch import APIRequestContext as APIRequestContextImpl
+from playwright._impl._fetch import APIResponse as APIResponseImpl
 from playwright._impl._file_chooser import FileChooser as FileChooserImpl
+from playwright._impl._form_data import FormData
 from playwright._impl._frame import Frame as FrameImpl
+from playwright._impl._helper import to_milliseconds
 from playwright._impl._input import Keyboard as KeyboardImpl
 from playwright._impl._input import Mouse as MouseImpl
 from playwright._impl._input import Touchscreen as TouchscreenImpl
 from playwright._impl._js_handle import JSHandle as JSHandleImpl
-from playwright._impl._logger import log_api
+from playwright._impl._locator import FrameLocator as FrameLocatorImpl
+from playwright._impl._locator import Locator as LocatorImpl
 from playwright._impl._network import Request as RequestImpl
 from playwright._impl._network import Response as ResponseImpl
 from playwright._impl._network import Route as RouteImpl
 from playwright._impl._network import WebSocket as WebSocketImpl
-from playwright._impl._page import BindingCall as BindingCallImpl
+from playwright._impl._network import WebSocketRoute as WebSocketRouteImpl
 from playwright._impl._page import Page as PageImpl
 from playwright._impl._page import Worker as WorkerImpl
 from playwright._impl._playwright import Playwright as PlaywrightImpl
+from playwright._impl._screencast import Screencast as ScreencastImpl
 from playwright._impl._selectors import Selectors as SelectorsImpl
-from playwright._impl._sync_base import EventContextManager, SyncBase, mapping
+from playwright._impl._sync_base import (
+    EventContextManager,
+    SyncBase,
+    SyncContextManager,
+    mapping,
+)
+from playwright._impl._tracing import Tracing as TracingImpl
 from playwright._impl._video import Video as VideoImpl
-
-NoneType = type(None)
+from playwright._impl._web_error import WebError as WebErrorImpl
 
 
 class Request(SyncBase):
-    def __init__(self, obj: RequestImpl):
-        super().__init__(obj)
 
     @property
     def url(self) -> str:
@@ -87,14 +115,32 @@ def resource_type(self) -> str:
         """Request.resource_type
 
         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`.
+        following: `document`, `stylesheet`, `image`, `media`, `font`, `script`, `texttrack`, `xhr`, `fetch`,
+        `eventsource`, `websocket`, `manifest`, `other`.
 
         Returns
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.resourceType)
+        return mapping.from_maybe_impl(self._impl_obj.resource_type)
+
+    @property
+    def service_worker(self) -> typing.Optional["Worker"]:
+        """Request.service_worker
+
+        The Service `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()` available.
+
+        Returns
+        -------
+        Union[Worker, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.service_worker)
 
     @property
     def method(self) -> str:
@@ -109,162 +155,284 @@ def method(self) -> str:
         return mapping.from_maybe_impl(self._impl_obj.method)
 
     @property
-    def post_data(self) -> typing.Union[str, NoneType]:
+    def post_data(self) -> typing.Optional[str]:
         """Request.post_data
 
         Request's post body, if any.
 
         Returns
         -------
-        Optional[str]
+        Union[str, None]
         """
-        return mapping.from_maybe_impl(self._impl_obj.postData)
+        return mapping.from_maybe_impl(self._impl_obj.post_data)
 
     @property
-    def post_data_json(self) -> typing.Union[typing.Dict, NoneType]:
+    def post_data_json(self) -> typing.Optional[typing.Any]:
         """Request.post_data_json
 
         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.
 
         Returns
         -------
-        Optional[Dict]
+        Union[Any, None]
         """
-        return mapping.from_maybe_impl(self._impl_obj.postDataJSON)
+        return mapping.from_maybe_impl(self._impl_obj.post_data_json)
 
     @property
-    def post_data_buffer(self) -> typing.Union[bytes, NoneType]:
+    def post_data_buffer(self) -> typing.Optional[bytes]:
         """Request.post_data_buffer
 
         Request's post body in a binary form, if any.
 
         Returns
         -------
-        Optional[bytes]
+        Union[bytes, None]
         """
-        return mapping.from_maybe_impl(self._impl_obj.postDataBuffer)
+        return mapping.from_maybe_impl(self._impl_obj.post_data_buffer)
 
     @property
-    def headers(self) -> typing.Dict[str, str]:
-        """Request.headers
+    def existing_response(self) -> typing.Optional["Response"]:
+        """Request.existing_response
+
+        Returns the `Response` object if the response has already been received, `null` otherwise.
 
-        An object with HTTP headers associated with the request. All header names are lower-case.
+        Unlike `request.response()`, this method does not wait for the response to arrive. It returns immediately
+        with the response object if the response has been received, or `null` if the response has not been received yet.
 
         Returns
         -------
-        Dict[str, str]
+        Union[Response, None]
         """
-        return mapping.from_maybe_impl(self._impl_obj.headers)
+        return mapping.from_impl_nullable(self._impl_obj.existing_response)
 
     @property
     def frame(self) -> "Frame":
         """Request.frame
 
-        Returns the Frame that initiated this request.
+        Returns the `Frame` that initiated this request.
 
-        Returns
-        -------
-        Frame
-        """
-        return mapping.from_impl(self._impl_obj.frame)
+        **Usage**
 
-    @property
-    def is_navigation_request(self) -> bool:
-        """Request.is_navigation_request
+        ```py
+        frame_url = request.frame.url
+        ```
 
-        Whether this request is driving frame's navigation.
+        **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.is_navigation_request()` to check that.
+
+        Here is an example that handles all the cases:
 
         Returns
         -------
-        bool
+        Frame
         """
-        return mapping.from_maybe_impl(self._impl_obj.isNavigationRequest)
+        return mapping.from_impl(self._impl_obj.frame)
 
     @property
-    def redirected_from(self) -> typing.Union["Request", NoneType]:
+    def redirected_from(self) -> typing.Optional["Request"]:
         """Request.redirected_from
 
         Request that was redirected by the server to this one, if any.
-        When the server responds with a redirect, Playwright creates a new Request object. The two requests are connected by
-        `redirectedFrom()` and `redirectedTo()` methods. When multiple server redirects has happened, it is possible to
+
+        When the server responds with a redirect, Playwright creates a new `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`:
+
+        ```py
+        response = page.goto(\"http://example.com\")
+        print(response.request.redirected_from.url) # \"http://example.com\"
+        ```
+
         If the website `https://google.com` has no redirects:
 
+        ```py
+        response = page.goto(\"https://google.com\")
+        print(response.request.redirected_from) # None
+        ```
+
         Returns
         -------
-        Optional[Request]
+        Union[Request, None]
         """
-        return mapping.from_impl_nullable(self._impl_obj.redirectedFrom)
+        return mapping.from_impl_nullable(self._impl_obj.redirected_from)
 
     @property
-    def redirected_to(self) -> typing.Union["Request", NoneType]:
+    def redirected_to(self) -> typing.Optional["Request"]:
         """Request.redirected_to
 
         New request issued by the browser if the server responded with redirect.
-        This method is the opposite of request.redirected_from():
+
+        **Usage**
+
+        This method is the opposite of `request.redirected_from()`:
+
+        ```py
+        assert request.redirected_from.redirected_to == request
+        ```
 
         Returns
         -------
-        Optional[Request]
+        Union[Request, None]
         """
-        return mapping.from_impl_nullable(self._impl_obj.redirectedTo)
+        return mapping.from_impl_nullable(self._impl_obj.redirected_to)
 
     @property
-    def failure(self) -> typing.Union[str, NoneType]:
+    def failure(self) -> typing.Optional[str]:
         """Request.failure
 
         The method returns `null` unless this request has failed, as reported by `requestfailed` event.
+
+        **Usage**
+
         Example of logging of all the failed requests:
 
+        ```py
+        page.on(\"requestfailed\", lambda request: print(request.url + \" \" + request.failure))
+        ```
+
         Returns
         -------
-        Optional[str]
+        Union[str, None]
         """
         return mapping.from_maybe_impl(self._impl_obj.failure)
 
     @property
-    def timing(self) -> "ResourceTiming":
+    def timing(self) -> ResourceTiming:
         """Request.timing
 
-        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.
+        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**
+
+        ```py
+        with page.expect_event(\"requestfinished\") as request_info:
+            page.goto(\"http://example.com\")
+        request = request_info.value
+        print(request.timing)
+        ```
 
         Returns
         -------
-        {"startTime": float, "domainLookupStart": float, "domainLookupEnd": float, "connectStart": float, "secureConnectionStart": float, "connectEnd": float, "requestStart": float, "responseStart": float, "responseEnd": float}
+        {startTime: float, domainLookupStart: float, domainLookupEnd: float, connectStart: float, secureConnectionStart: float, connectEnd: float, requestStart: float, responseStart: float, responseEnd: float}
         """
         return mapping.from_impl(self._impl_obj.timing)
 
-    def response(self) -> typing.Union["Response", NoneType]:
+    @property
+    def headers(self) -> typing.Dict[str, str]:
+        """Request.headers
+
+        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.all_headers()` for complete
+        list of headers that include `cookie` information.
+
+        Returns
+        -------
+        Dict[str, str]
+        """
+        return mapping.from_maybe_impl(self._impl_obj.headers)
+
+    def sizes(self) -> RequestSizes:
+        """Request.sizes
+
+        Returns resource size information for given request.
+
+        Returns
+        -------
+        {requestBodySize: int, requestHeadersSize: int, responseBodySize: int, responseHeadersSize: int}
+        """
+
+        return mapping.from_impl(self._sync(self._impl_obj.sizes()))
+
+    def response(self) -> typing.Optional["Response"]:
         """Request.response
 
-        Returns the matching Response object, or `null` if the response was not received due to error.
+        Returns the matching `Response` object, or `null` if the response was not received due to error.
 
         Returns
         -------
-        Optional[Response]
+        Union[Response, None]
         """
 
-        try:
-            log_api("=> request.response started")
-            result = mapping.from_impl_nullable(self._sync(self._impl_obj.response()))
-            log_api("<= request.response succeded")
-            return result
-        except Exception as e:
-            log_api("<= request.response failed")
-            raise e
+        return mapping.from_impl_nullable(self._sync(self._impl_obj.response()))
+
+    def is_navigation_request(self) -> bool:
+        """Request.is_navigation_request
+
+        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()` available.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.is_navigation_request())
+
+    def all_headers(self) -> typing.Dict[str, str]:
+        """Request.all_headers
+
+        An object with all the request HTTP headers associated with this request. The header names are lower-cased.
+
+        Returns
+        -------
+        Dict[str, str]
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.all_headers()))
+
+    def headers_array(self) -> typing.List[NameValue]:
+        """Request.headers_array
+
+        An array with all the request HTTP headers associated with this request. Unlike `request.all_headers()`,
+        header names are NOT lower-cased. Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple
+        times.
+
+        Returns
+        -------
+        List[{name: str, value: str}]
+        """
+
+        return mapping.from_impl_list(self._sync(self._impl_obj.headers_array()))
+
+    def header_value(self, name: str) -> typing.Optional[str]:
+        """Request.header_value
+
+        Returns the value of the header matching the name. The name is case-insensitive.
+
+        Parameters
+        ----------
+        name : str
+            Name of the header.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.header_value(name=name))
+        )
 
 
 mapping.register(RequestImpl, Request)
 
 
 class Response(SyncBase):
-    def __init__(self, obj: ResponseImpl):
-        super().__init__(obj)
 
     @property
     def url(self) -> str:
@@ -306,19 +474,21 @@ def status(self) -> int:
     def status_text(self) -> str:
         """Response.status_text
 
-        Contains the status text of the response (e.g. usually an "OK" for a success).
+        Contains the status text of the response (e.g. usually an \"OK\" for a success).
 
         Returns
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.statusText)
+        return mapping.from_maybe_impl(self._impl_obj.status_text)
 
     @property
     def headers(self) -> typing.Dict[str, str]:
         """Response.headers
 
-        Returns the object with HTTP headers associated with the response. All header names are lower-case.
+        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.all_headers()` for complete
+        list of headers that include `cookie` information.
 
         Returns
         -------
@@ -326,11 +496,24 @@ def headers(self) -> typing.Dict[str, str]:
         """
         return mapping.from_maybe_impl(self._impl_obj.headers)
 
+    @property
+    def from_service_worker(self) -> bool:
+        """Response.from_service_worker
+
+        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)).
+
+        Returns
+        -------
+        bool
+        """
+        return mapping.from_maybe_impl(self._impl_obj.from_service_worker)
+
     @property
     def request(self) -> "Request":
         """Response.request
 
-        Returns the matching Request object.
+        Returns the matching `Request` object.
 
         Returns
         -------
@@ -342,7 +525,7 @@ def request(self) -> "Request":
     def frame(self) -> "Frame":
         """Response.frame
 
-        Returns the Frame that initiated this response.
+        Returns the `Frame` that initiated this response.
 
         Returns
         -------
@@ -350,24 +533,115 @@ def frame(self) -> "Frame":
         """
         return mapping.from_impl(self._impl_obj.frame)
 
-    def finished(self) -> typing.Union[str, NoneType]:
-        """Response.finished
+    def all_headers(self) -> typing.Dict[str, str]:
+        """Response.all_headers
 
-        Waits for this response to finish, returns failure error if request failed.
+        An object with all the response HTTP headers associated with this response.
 
         Returns
         -------
-        Optional[str]
+        Dict[str, str]
         """
 
-        try:
-            log_api("=> response.finished started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.finished()))
-            log_api("<= response.finished succeded")
-            return result
-        except Exception as e:
-            log_api("<= response.finished failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.all_headers()))
+
+    def headers_array(self) -> typing.List[NameValue]:
+        """Response.headers_array
+
+        An array with all the request HTTP headers associated with this response. Unlike `response.all_headers()`,
+        header names are NOT lower-cased. Headers with multiple entries, such as `Set-Cookie`, appear in the array multiple
+        times.
+
+        Returns
+        -------
+        List[{name: str, value: str}]
+        """
+
+        return mapping.from_impl_list(self._sync(self._impl_obj.headers_array()))
+
+    def header_value(self, name: str) -> typing.Optional[str]:
+        """Response.header_value
+
+        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.
+
+        Parameters
+        ----------
+        name : str
+            Name of the header.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.header_value(name=name))
+        )
+
+    def header_values(self, name: str) -> typing.List[str]:
+        """Response.header_values
+
+        Returns all values of the headers matching the name, for example `set-cookie`. The name is case-insensitive.
+
+        Parameters
+        ----------
+        name : str
+            Name of the header.
+
+        Returns
+        -------
+        List[str]
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.header_values(name=name))
+        )
+
+    def server_addr(self) -> typing.Optional[RemoteAddr]:
+        """Response.server_addr
+
+        Returns the IP address and port of the server.
+
+        Returns
+        -------
+        Union[{ipAddress: str, port: int}, None]
+        """
+
+        return mapping.from_impl_nullable(self._sync(self._impl_obj.server_addr()))
+
+    def security_details(self) -> typing.Optional[SecurityDetails]:
+        """Response.security_details
+
+        Returns SSL and other security information.
+
+        Returns
+        -------
+        Union[{issuer: Union[str, None], protocol: Union[str, None], subjectName: Union[str, None], validFrom: Union[float, None], validTo: Union[float, None]}, None]
+        """
+
+        return mapping.from_impl_nullable(self._sync(self._impl_obj.security_details()))
+
+    def http_version(self) -> str:
+        """Response.http_version
+
+        Returns the http version used by the response.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.http_version()))
+
+    def finished(self) -> None:
+        """Response.finished
+
+        Waits for this response to finish, returns always `null`.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.finished()))
 
     def body(self) -> bytes:
         """Response.body
@@ -379,14 +653,7 @@ def body(self) -> bytes:
         bytes
         """
 
-        try:
-            log_api("=> response.body started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.body()))
-            log_api("<= response.body succeded")
-            return result
-        except Exception as e:
-            log_api("<= response.body failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.body()))
 
     def text(self) -> str:
         """Response.text
@@ -398,42 +665,27 @@ def text(self) -> str:
         str
         """
 
-        try:
-            log_api("=> response.text started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.text()))
-            log_api("<= response.text succeded")
-            return result
-        except Exception as e:
-            log_api("<= response.text failed")
-            raise e
-
-    def json(self) -> typing.Union[typing.Dict, typing.List]:
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.text()))
+
+    def json(self) -> typing.Any:
         """Response.json
 
         Returns the JSON representation of response body.
+
         This method will throw if the response body is not parsable via `JSON.parse`.
 
         Returns
         -------
-        Union[Dict, List]
+        Any
         """
 
-        try:
-            log_api("=> response.json started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.json()))
-            log_api("<= response.json succeded")
-            return result
-        except Exception as e:
-            log_api("<= response.json failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.json()))
 
 
 mapping.register(ResponseImpl, Response)
 
 
 class Route(SyncBase):
-    def __init__(self, obj: RouteImpl):
-        super().__init__(obj)
 
     @property
     def request(self) -> "Request":
@@ -447,216 +699,594 @@ def request(self) -> "Request":
         """
         return mapping.from_impl(self._impl_obj.request)
 
-    def abort(self, error_code: str = None) -> NoneType:
+    def abort(self, error_code: typing.Optional[str] = None) -> None:
         """Route.abort
 
         Aborts the route's request.
 
         Parameters
         ----------
-        error_code : Optional[str]
+        error_code : Union[str, None]
             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.
-        """
-
-        try:
-            log_api("=> route.abort started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.abort(errorCode=error_code))
-            )
-            log_api("<= route.abort succeded")
-            return result
-        except Exception as e:
-            log_api("<= route.abort failed")
-            raise e
+            - `'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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.abort(errorCode=error_code))
+        )
 
     def fulfill(
         self,
-        status: int = None,
-        headers: typing.Union[typing.Dict[str, str]] = None,
-        body: typing.Union[str, bytes] = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content_type: str = None,
-    ) -> NoneType:
+        *,
+        status: typing.Optional[int] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        body: typing.Optional[typing.Union[str, bytes]] = None,
+        json: typing.Optional[typing.Any] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content_type: typing.Optional[str] = None,
+        response: typing.Optional["APIResponse"] = None,
+    ) -> None:
         """Route.fulfill
 
         Fulfills route's request with given response.
+
+        **Usage**
+
         An example of fulfilling all requests with 404 responses:
+
+        ```py
+        page.route(\"**/*\", lambda route: route.fulfill(
+            status=404,
+            content_type=\"text/plain\",
+            body=\"not found!\"))
+        ```
+
         An example of serving static file:
 
+        ```py
+        page.route(\"**/xhr_endpoint\", lambda route: route.fulfill(path=\"mock_data.json\"))
+        ```
+
         Parameters
         ----------
-        status : Optional[int]
+        status : Union[int, None]
             Response status code, defaults to `200`.
-        headers : Optional[Dict[str, str]]
-            Optional response headers. Header values will be converted to a string.
-        body : Union[str, bytes, NoneType]
-            Optional response body.
-        path : Union[str, pathlib.Path, NoneType]
-            Optional 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 current working directory.
-        content_type : Optional[str]
+        headers : Union[Dict[str, str], None]
+            Response headers. Header values will be converted to a string.
+        body : Union[bytes, str, None]
+            Response body.
+        json : Union[Any, None]
+            JSON response. This method will set the content type to `application/json` if not set.
+        path : Union[pathlib.Path, str, None]
+            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.
+        content_type : Union[str, None]
             If set, equals to setting `Content-Type` response header.
-        """
-
-        try:
-            log_api("=> route.fulfill started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.fulfill(
-                        status=status,
-                        headers=mapping.to_impl(headers),
-                        body=body,
-                        path=path,
-                        contentType=content_type,
-                    )
-                )
-            )
-            log_api("<= route.fulfill succeded")
-            return result
-        except Exception as e:
-            log_api("<= route.fulfill failed")
-            raise e
+        response : Union[APIResponse, None]
+            `APIResponse` to fulfill route's request with. Individual fields of the response (such as headers) can be
+            overridden using fulfill options.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.fulfill(
+                    status=status,
+                    headers=mapping.to_impl(headers),
+                    body=body,
+                    json=mapping.to_impl(json),
+                    path=path,
+                    contentType=content_type,
+                    response=response._impl_obj if response else None,
+                )
+            )
+        )
 
-    def continue_(
+    def fetch(
         self,
-        url: str = None,
-        method: str = None,
-        headers: typing.Union[typing.Dict[str, str]] = None,
-        post_data: typing.Union[str, bytes] = None,
-    ) -> NoneType:
-        """Route.continue_
+        *,
+        url: typing.Optional[str] = None,
+        method: typing.Optional[str] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> "APIResponse":
+        """Route.fetch
+
+        Performs the request and fetches result without fulfilling it, so that the response could be modified and then
+        fulfilled.
+
+        **Usage**
+
+        ```py
+        def handle(route):
+            response = route.fetch()
+            json = response.json()
+            json[\"message\"][\"big_red_dog\"] = []
+            route.fulfill(response=response, json=json)
+
+        page.route(\"https://dog.ceo/api/breeds/list/all\", handle)
+        ```
+
+        **Details**
 
-        Continues route's request with optional overrides.
+        Note that `headers` option will apply to the fetched request as well as any redirects initiated by it. If you want
+        to only apply `headers` to the original request, but not to redirects, look into `route.continue_()`
+        instead.
 
         Parameters
         ----------
-        url : Optional[str]
+        url : Union[str, None]
             If set changes the request URL. New URL must have same protocol as original one.
-        method : Optional[str]
-            If set changes the request method (e.g. GET or POST)
-        headers : Optional[Dict[str, str]]
+        method : Union[str, None]
+            If set changes the request method (e.g. GET or POST).
+        headers : Union[Dict[str, str], None]
             If set changes the request HTTP headers. Header values will be converted to a string.
-        post_data : Union[str, bytes, NoneType]
-            If set changes the post data of request
-        """
+        post_data : Union[Any, bytes, str, None]
+            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.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
 
-        try:
-            log_api("=> route.continue_ started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.continue_(
-                        url=url,
-                        method=method,
-                        headers=mapping.to_impl(headers),
-                        postData=post_data,
-                    )
+        Returns
+        -------
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.fetch(
+                    url=url,
+                    method=method,
+                    headers=mapping.to_impl(headers),
+                    postData=mapping.to_impl(post_data),
+                    maxRedirects=max_redirects,
+                    maxRetries=max_retries,
+                    timeout=to_milliseconds(timeout),
                 )
             )
-            log_api("<= route.continue_ succeded")
-            return result
-        except Exception as e:
-            log_api("<= route.continue_ failed")
-            raise e
+        )
 
+    def fallback(
+        self,
+        *,
+        url: typing.Optional[str] = None,
+        method: typing.Optional[str] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+    ) -> None:
+        """Route.fallback
+
+        Continues route's request with optional overrides. The method is similar to `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.
+
+        ```py
+        page.route(\"**/*\", lambda route: route.abort())  # Runs last.
+        page.route(\"**/*\", lambda route: route.fallback())  # Runs second.
+        page.route(\"**/*\", lambda route: route.fallback())  # Runs first.
+        ```
 
-mapping.register(RouteImpl, Route)
+        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.
+
+        ```py
+        # Handle GET requests.
+        def handle_get(route):
+            if route.request.method != \"GET\":
+                route.fallback()
+                return
+          # Handling GET only.
+          # ...
+
+        # Handle POST requests.
+        def handle_post(route):
+            if route.request.method != \"POST\":
+                route.fallback()
+                return
+          # Handling POST only.
+          # ...
+
+        page.route(\"**/*\", handle_get)
+        page.route(\"**/*\", handle_post)
+        ```
 
+        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.
 
-class WebSocket(SyncBase):
-    def __init__(self, obj: WebSocketImpl):
-        super().__init__(obj)
+        ```py
+        def handle(route, request):
+            # override headers
+            headers = {
+                **request.headers,
+                \"foo\": \"foo-value\", # set \"foo\" header
+                \"bar\": None # remove \"bar\" header
+            }
+            route.fallback(headers=headers)
 
-    @property
-    def url(self) -> str:
-        """WebSocket.url
+        page.route(\"**/*\", handle)
+        ```
 
-        Contains the URL of the WebSocket.
+        Use `route.continue_()` to immediately send the request to the network, other matching handlers won't be
+        invoked in that case.
 
-        Returns
-        -------
-        str
+        Parameters
+        ----------
+        url : Union[str, None]
+            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.
+        method : Union[str, None]
+            If set changes the request method (e.g. GET or POST).
+        headers : Union[Dict[str, str], None]
+            If set changes the request HTTP headers. Header values will be converted to a string.
+        post_data : Union[Any, bytes, str, None]
+            If set changes the post data of request.
         """
-        return mapping.from_maybe_impl(self._impl_obj.url)
 
-    def wait_for_event(
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.fallback(
+                    url=url,
+                    method=method,
+                    headers=mapping.to_impl(headers),
+                    postData=mapping.to_impl(post_data),
+                )
+            )
+        )
+
+    def continue_(
         self,
-        event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
-    ) -> typing.Any:
-        """WebSocket.wait_for_event
+        *,
+        url: typing.Optional[str] = None,
+        method: typing.Optional[str] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        post_data: typing.Optional[typing.Union[typing.Any, str, bytes]] = None,
+    ) -> None:
+        """Route.continue_
 
-        Returns the event data value.
-        Waits for event to fire and passes its value into the predicate function. Resolves when the predicate returns truthy
-        value. Will throw an error if the webSocket is closed before the event is fired.
+        Sends route's request to the network with optional overrides.
 
-        Parameters
-        ----------
-        event : str
-            Event name, same one would pass into `webSocket.on(event)`.
+        **Usage**
 
-        Returns
-        -------
-        Any
-        """
+        ```py
+        def handle(route, request):
+            # override headers
+            headers = {
+                **request.headers,
+                \"foo\": \"foo-value\", # set \"foo\" header
+                \"bar\": None # remove \"bar\" header
+            }
+            route.continue_(headers=headers)
 
-        try:
-            log_api("=> web_socket.wait_for_event started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.waitForEvent(
-                        event=event,
-                        predicate=self._wrap_handler(predicate),
-                        timeout=timeout,
-                    )
-                )
-            )
-            log_api("<= web_socket.wait_for_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= web_socket.wait_for_event failed")
-            raise e
+        page.route(\"**/*\", handle)
+        ```
 
-    def expect_event(
-        self,
+        **Details**
+
+        The `headers` option applies to both the routed request and any redirects it initiates. However, `url`, `method`,
+        and `postData` only apply to the original request and are not carried over to redirected requests.
+
+        `route.continue_()` will immediately send the request to the network, other matching handlers won't be
+        invoked. Use `route.fallback()` If you want next matching handler in the chain to be invoked.
+
+        **NOTE** Some request headers are **forbidden** and cannot be overridden (for example, `Cookie`, `Host`,
+        `Content-Length` and others, see
+        [this MDN page](https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_request_header) for full list). If an
+        override is provided for a forbidden header, it will be ignored and the original request header will be used.
+
+        To set custom cookies, use `browser_context.add_cookies()`.
+
+        Parameters
+        ----------
+        url : Union[str, None]
+            If set changes the request URL. New URL must have same protocol as original one.
+        method : Union[str, None]
+            If set changes the request method (e.g. GET or POST).
+        headers : Union[Dict[str, str], None]
+            If set changes the request HTTP headers. Header values will be converted to a string.
+        post_data : Union[Any, bytes, str, None]
+            If set changes the post data of request.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.continue_(
+                    url=url,
+                    method=method,
+                    headers=mapping.to_impl(headers),
+                    postData=mapping.to_impl(post_data),
+                )
+            )
+        )
+
+
+mapping.register(RouteImpl, Route)
+
+
+class WebSocket(SyncBase):
+
+    @typing.overload
+    def on(
+        self, event: Literal["close"], f: typing.Callable[["WebSocket"], "None"]
+    ) -> None:
+        """
+        Fired when the websocket closes."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["framereceived"],
+        f: typing.Callable[["typing.Union[bytes, str]"], "None"],
+    ) -> None:
+        """
+        Fired when the websocket receives a frame."""
+
+    @typing.overload
+    def on(
+        self,
+        event: Literal["framesent"],
+        f: typing.Callable[["typing.Union[bytes, str]"], "None"],
+    ) -> None:
+        """
+        Fired when the websocket sends a frame."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["socketerror"], f: typing.Callable[["str"], "None"]
+    ) -> None:
+        """
+        Fired when the websocket has an error."""
+
+    def on(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self, event: Literal["close"], f: typing.Callable[["WebSocket"], "None"]
+    ) -> None:
+        """
+        Fired when the websocket closes."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["framereceived"],
+        f: typing.Callable[["typing.Union[bytes, str]"], "None"],
+    ) -> None:
+        """
+        Fired when the websocket receives a frame."""
+
+    @typing.overload
+    def once(
+        self,
+        event: Literal["framesent"],
+        f: typing.Callable[["typing.Union[bytes, str]"], "None"],
+    ) -> None:
+        """
+        Fired when the websocket sends a frame."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["socketerror"], f: typing.Callable[["str"], "None"]
+    ) -> None:
+        """
+        Fired when the websocket has an error."""
+
+    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def url(self) -> str:
+        """WebSocket.url
+
+        Contains the URL of the WebSocket.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["WebSocket"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framereceived"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["typing.Union[bytes, str]"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framesent"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["typing.Union[bytes, str]"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["socketerror"],
+        predicate: typing.Optional[typing.Callable[["str"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["str"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager[typing.Any]: ...
+
+    def expect_event(
+        self,
         event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
     ) -> EventContextManager:
         """WebSocket.expect_event
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
-
-        with page.expect_event() as event_info:
-            page.click("button")
-        value = event_info.value
+        Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+        value. Will throw an error if the webSocket is closed before the event is fired. Returns the event data value.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        event : str
+            Event name, same one would pass into `webSocket.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager
         """
         return EventContextManager(
-            self, self._impl_obj.waitForEvent(event, predicate, timeout)
+            self,
+            self._impl_obj.expect_event(
+                event=event,
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebSocket": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["framereceived"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "typing.Union[bytes, str]": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["framesent"],
+        predicate: typing.Optional[
+            typing.Callable[["typing.Union[bytes, str]"], bool]
+        ] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "typing.Union[bytes, str]": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["socketerror"],
+        predicate: typing.Optional[typing.Callable[["str"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "str": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
+
+    def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Any:
+        """WebSocket.wait_for_event
+
+        **NOTE** In most cases, you should use `web_socket.expect_event()`.
+
+        Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function
+        and waits for `predicate(event)` to return a truthy value. Will throw an error if the socket is closed before the
+        `event` is fired.
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_event(
+                    event=event,
+                    predicate=self._wrap_handler(predicate),
+                    timeout=to_milliseconds(timeout),
+                )
+            )
         )
 
     def is_closed(self) -> bool:
@@ -669,41 +1299,197 @@ def is_closed(self) -> bool:
         bool
         """
 
-        try:
-            log_api("=> web_socket.is_closed started")
-            result = mapping.from_maybe_impl(self._impl_obj.isClosed())
-            log_api("<= web_socket.is_closed succeded")
-            return result
-        except Exception as e:
-            log_api("<= web_socket.is_closed failed")
-            raise e
+        return mapping.from_maybe_impl(self._impl_obj.is_closed())
 
 
 mapping.register(WebSocketImpl, WebSocket)
 
 
+class WebSocketRoute(SyncBase):
+
+    @property
+    def url(self) -> str:
+        """WebSocketRoute.url
+
+        URL of the WebSocket created in the page.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    @property
+    def protocols(self) -> typing.List[str]:
+        """WebSocketRoute.protocols
+
+        The list of WebSocket subprotocols requested by the page, as passed via the second argument to the
+        [`WebSocket` constructor](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/WebSocket). Corresponds to the
+        `Sec-WebSocket-Protocol` request header.
+
+        Returns an empty array if no protocols were specified.
+
+        **Usage**
+
+        ```py
+        def handler(ws: WebSocketRoute):
+          if \"chat.v2\" in ws.protocols:
+            ws.on_message(lambda message: ws.send(f\"v2:{message}\"))
+          else:
+            ws.close(code=1002, reason=\"Unsupported protocol\")
+
+        page.route_web_socket(\"wss://example.com/ws\", handler)
+        ```
+
+        Returns
+        -------
+        List[str]
+        """
+        return mapping.from_maybe_impl(self._impl_obj.protocols)
+
+    def close(
+        self, *, code: typing.Optional[int] = None, reason: typing.Optional[str] = None
+    ) -> None:
+        """WebSocketRoute.close
+
+        Closes one side of the WebSocket connection.
+
+        Parameters
+        ----------
+        code : Union[int, None]
+            Optional [close code](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#code).
+        reason : Union[str, None]
+            Optional [close reason](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close#reason).
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.close(code=code, reason=reason))
+        )
+
+    def connect_to_server(self) -> "WebSocketRoute":
+        """WebSocketRoute.connect_to_server
+
+        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` 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
+          `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 `web_socket_route.on_message()` is
+          called on the original `WebSocketRoute`.
+
+        See examples at the top for more details.
+
+        Returns
+        -------
+        WebSocketRoute
+        """
+
+        return mapping.from_impl(self._impl_obj.connect_to_server())
+
+    def send(self, message: typing.Union[str, bytes]) -> None:
+        """WebSocketRoute.send
+
+        Sends a message to the WebSocket. When called on the original WebSocket, sends the message to the page. When called
+        on the result of `web_socket_route.connect_to_server()`, sends the message to the server. See examples at the
+        top for more details.
+
+        Parameters
+        ----------
+        message : Union[bytes, str]
+            Message to send.
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.send(message=message))
+
+    def on_message(
+        self, handler: typing.Callable[[typing.Union[str, bytes]], typing.Any]
+    ) -> None:
+        """WebSocketRoute.on_message
+
+        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 `web_socket_route.send()`, forwarding them to the server-side connection
+        returned by `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 `web_socket_route.send()`. See examples at the top for more details.
+
+        Calling this method again will override the handler with a new one.
+
+        Parameters
+        ----------
+        handler : Callable[[Union[bytes, str]], Any]
+            Function that will handle messages.
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.on_message(handler=self._wrap_handler(handler))
+        )
+
+    def on_close(
+        self,
+        handler: typing.Callable[
+            [typing.Optional[int], typing.Optional[str]], typing.Any
+        ],
+    ) -> None:
+        """WebSocketRoute.on_close
+
+        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 `web_socket_route.on_close()` handler is set up, the default forwarding of closure is disabled,
+        and handler should take care of it.
+
+        Parameters
+        ----------
+        handler : Callable[[Union[int, None], Union[str, None]], Any]
+            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).
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.on_close(handler=self._wrap_handler(handler))
+        )
+
+
+mapping.register(WebSocketRouteImpl, WebSocketRoute)
+
+
 class Keyboard(SyncBase):
-    def __init__(self, obj: KeyboardImpl):
-        super().__init__(obj)
 
-    def down(self, key: str) -> NoneType:
+    def down(self, key: str) -> None:
         """Keyboard.down
 
         Dispatches a `keydown` event.
-        `key` can specify the intended keyboardEvent.key
-        value or a single character to generate the text for. A superset of the `key` values can be found
-        here. Examples of the keys are:
+
+        `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` 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 suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        `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` in the upper case.
+
         If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective
         texts.
-        If `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).
-        After the key is pressed once, subsequent calls to keyboard.down(key) will have
-        repeat set to true. To release the key, use
-        keyboard.up(key).
+
+        If `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()`.
+
+        After the key is pressed once, subsequent calls to `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()`.
 
         **NOTE** Modifier keys DO influence `keyboard.down`. Holding down `Shift` will type the text in upper case.
 
@@ -713,16 +1499,9 @@ def down(self, key: str) -> NoneType:
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
         """
 
-        try:
-            log_api("=> keyboard.down started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.down(key=key)))
-            log_api("<= keyboard.down succeded")
-            return result
-        except Exception as e:
-            log_api("<= keyboard.down failed")
-            raise e
-
-    def up(self, key: str) -> NoneType:
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.down(key=key)))
+
+    def up(self, key: str) -> None:
         """Keyboard.up
 
         Dispatches a `keyup` event.
@@ -733,21 +1512,21 @@ def up(self, key: str) -> NoneType:
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
         """
 
-        try:
-            log_api("=> keyboard.up started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.up(key=key)))
-            log_api("<= keyboard.up succeded")
-            return result
-        except Exception as e:
-            log_api("<= keyboard.up failed")
-            raise e
-
-    def insert_text(self, text: str) -> NoneType:
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.up(key=key)))
+
+    def insert_text(self, text: str) -> None:
         """Keyboard.insert_text
 
         Dispatches only `input` event, does not emit the `keydown`, `keyup` or `keypress` events.
 
-        **NOTE** Modifier keys DO NOT effect `keyboard.insert_text`. Holding down `Shift` will not type the text in upper case.
+        **Usage**
+
+        ```py
+        page.keyboard.insert_text(\"嗨\")
+        ```
+
+        **NOTE** Modifier keys DO NOT effect `keyboard.insertText`. Holding down `Shift` will not type the text in upper
+        case.
 
         Parameters
         ----------
@@ -755,88 +1534,103 @@ def insert_text(self, text: str) -> NoneType:
             Sets input to the specified text value.
         """
 
-        try:
-            log_api("=> keyboard.insert_text started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.insertText(text=text))
-            )
-            log_api("<= keyboard.insert_text succeded")
-            return result
-        except Exception as e:
-            log_api("<= keyboard.insert_text failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.insert_text(text=text))
+        )
 
-    def type(self, text: str, delay: int = None) -> NoneType:
+    def type(self, text: str, *, delay: typing.Optional[float] = None) -> None:
         """Keyboard.type
 
+        **NOTE** In most cases, you should use `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.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]).
+
+        To press a special key, like `Control` or `ArrowDown`, use `keyboard.press()`.
+
+        **Usage**
+
+        ```py
+        page.keyboard.type(\"Hello\") # types instantly
+        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.
+
         Parameters
         ----------
         text : str
             A text to type into a focused element.
-        delay : Optional[int]
+        delay : Union[float, None]
             Time to wait between key presses in milliseconds. Defaults to 0.
         """
 
-        try:
-            log_api("=> keyboard.type started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.type(text=text, delay=delay))
-            )
-            log_api("<= keyboard.type succeded")
-            return result
-        except Exception as e:
-            log_api("<= keyboard.type failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.type(text=text, delay=delay))
+        )
 
-    def press(self, key: str, delay: int = None) -> NoneType:
+    def press(self, key: str, *, delay: typing.Optional[float] = None) -> None:
         """Keyboard.press
 
-        `key` can specify the intended keyboardEvent.key
-        value or a single character to generate the text for. A superset of the `key` values can be found
-        here. Examples of the keys are:
+        **NOTE** In most cases, you should use `locator.press()` instead.
+
+        `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` 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 suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        `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` in the upper case.
+
         If `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"` or `key: "Control+Shift+T"` are supported as well. When speficied with the
-        modifier, modifier is pressed and being held while the subsequent key is being pressed.
-        Shortcut for keyboard.down(key) and keyboard.up(key).
+
+        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**
+
+        ```py
+        page = browser.new_page()
+        page.goto(\"https://keycode.info\")
+        page.keyboard.press(\"a\")
+        page.screenshot(path=\"a.png\")
+        page.keyboard.press(\"ArrowLeft\")
+        page.screenshot(path=\"arrow_left.png\")
+        page.keyboard.press(\"Shift+O\")
+        page.screenshot(path=\"o.png\")
+        browser.close()
+        ```
+
+        Shortcut for `keyboard.down()` and `keyboard.up()`.
 
         Parameters
         ----------
         key : str
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
-        delay : Optional[int]
+        delay : Union[float, None]
             Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
         """
 
-        try:
-            log_api("=> keyboard.press started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.press(key=key, delay=delay))
-            )
-            log_api("<= keyboard.press succeded")
-            return result
-        except Exception as e:
-            log_api("<= keyboard.press failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.press(key=key, delay=delay))
+        )
 
 
 mapping.register(KeyboardImpl, Keyboard)
 
 
 class Mouse(SyncBase):
-    def __init__(self, obj: MouseImpl):
-        super().__init__(obj)
 
-    def move(self, x: float, y: float, steps: int = None) -> NoneType:
+    def move(self, x: float, y: float, *, steps: typing.Optional[int] = None) -> None:
         """Mouse.move
 
         Dispatches a `mousemove` event.
@@ -844,268 +1638,251 @@ def move(self, x: float, y: float, steps: int = None) -> NoneType:
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
-        steps : Optional[int]
-            defaults to 1. Sends intermediate `mousemove` events.
+            Y coordinate relative to the main frame's viewport in CSS pixels.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
         """
 
-        try:
-            log_api("=> mouse.move started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.move(x=x, y=y, steps=steps))
-            )
-            log_api("<= mouse.move succeded")
-            return result
-        except Exception as e:
-            log_api("<= mouse.move failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.move(x=x, y=y, steps=steps))
+        )
 
     def down(
-        self, button: Literal["left", "middle", "right"] = None, click_count: int = None
-    ) -> NoneType:
+        self,
+        *,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+    ) -> None:
         """Mouse.down
 
         Dispatches a `mousedown` event.
 
         Parameters
         ----------
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
         """
 
-        try:
-            log_api("=> mouse.down started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.down(button=button, clickCount=click_count))
-            )
-            log_api("<= mouse.down succeded")
-            return result
-        except Exception as e:
-            log_api("<= mouse.down failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.down(button=button, clickCount=click_count))
+        )
 
     def up(
-        self, button: Literal["left", "middle", "right"] = None, click_count: int = None
-    ) -> NoneType:
+        self,
+        *,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+    ) -> None:
         """Mouse.up
 
         Dispatches a `mouseup` event.
 
         Parameters
         ----------
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
         """
 
-        try:
-            log_api("=> mouse.up started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.up(button=button, clickCount=click_count))
-            )
-            log_api("<= mouse.up succeded")
-            return result
-        except Exception as e:
-            log_api("<= mouse.up failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.up(button=button, clickCount=click_count))
+        )
 
     def click(
         self,
         x: float,
         y: float,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        click_count: int = None,
-    ) -> NoneType:
+        *,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+    ) -> None:
         """Mouse.click
 
-        Shortcut for mouse.move(x, y[, options]), mouse.down([options]), mouse.up([options]).
+        Shortcut for `mouse.move()`, `mouse.down()`, `mouse.up()`.
 
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
-        delay : Optional[int]
+            Y coordinate relative to the main frame's viewport in CSS pixels.
+        delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
         """
 
-        try:
-            log_api("=> mouse.click started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.click(
-                        x=x, y=y, delay=delay, button=button, clickCount=click_count
-                    )
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.click(
+                    x=x, y=y, delay=delay, button=button, clickCount=click_count
                 )
             )
-            log_api("<= mouse.click succeded")
-            return result
-        except Exception as e:
-            log_api("<= mouse.click failed")
-            raise e
+        )
 
     def dblclick(
         self,
         x: float,
         y: float,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-    ) -> NoneType:
+        *,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+    ) -> None:
         """Mouse.dblclick
 
-        Shortcut for mouse.move(x, y[, options]), mouse.down([options]), mouse.up([options]), mouse.down([options]) and mouse.up([options]).
+        Shortcut for `mouse.move()`, `mouse.down()`, `mouse.up()`, `mouse.down()` and
+        `mouse.up()`.
 
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
-        delay : Optional[int]
+            Y coordinate relative to the main frame's viewport in CSS pixels.
+        delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
         """
 
-        try:
-            log_api("=> mouse.dblclick started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.dblclick(x=x, y=y, delay=delay, button=button)
-                )
-            )
-            log_api("<= mouse.dblclick succeded")
-            return result
-        except Exception as e:
-            log_api("<= mouse.dblclick failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.dblclick(x=x, y=y, delay=delay, button=button))
+        )
 
+    def wheel(self, delta_x: float, delta_y: float) -> None:
+        """Mouse.wheel
 
-mapping.register(MouseImpl, Mouse)
+        Dispatches a `wheel` event. This method is usually used to manually scroll the page. See
+        [scrolling](https://playwright.dev/python/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.
 
-class Touchscreen(SyncBase):
-    def __init__(self, obj: TouchscreenImpl):
-        super().__init__(obj)
+        Parameters
+        ----------
+        delta_x : float
+            Pixels to scroll horizontally.
+        delta_y : float
+            Pixels to scroll vertically.
+        """
 
-    def tap(self, x: float, y: float) -> NoneType:
-        """Touchscreen.tap
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.wheel(deltaX=delta_x, deltaY=delta_y))
+        )
 
-        Dispatches a `touchstart` and `touchend` event with a single touch at the position (`x`,`y`).
+
+mapping.register(MouseImpl, Mouse)
+
+
+class Touchscreen(SyncBase):
+
+    def tap(self, x: float, y: float) -> None:
+        """Touchscreen.tap
+
+        Dispatches a `touchstart` and `touchend` event with a single touch at the position (`x`,`y`).
+
+        **NOTE** `page.tap()` the method will throw if `hasTouch` option of the browser context is false.
 
         Parameters
         ----------
         x : float
+            X coordinate relative to the main frame's viewport in CSS pixels.
         y : float
+            Y coordinate relative to the main frame's viewport in CSS pixels.
         """
 
-        try:
-            log_api("=> touchscreen.tap started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.tap(x=x, y=y)))
-            log_api("<= touchscreen.tap succeded")
-            return result
-        except Exception as e:
-            log_api("<= touchscreen.tap failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.tap(x=x, y=y)))
 
 
 mapping.register(TouchscreenImpl, Touchscreen)
 
 
 class JSHandle(SyncBase):
-    def __init__(self, obj: JSHandleImpl):
-        super().__init__(obj)
 
     def evaluate(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
+        self, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> typing.Any:
         """JSHandle.evaluate
 
-        Returns the return value of `pageFunction`
-        This method passes this handle as the first argument to `pageFunction`.
-        If `pageFunction` returns a Promise, then `handle.evaluate` would wait for the promise to resolve and return its
+        Returns the return value of `expression`.
+
+        This method passes this handle as the first argument to `expression`.
+
+        If `expression` returns a [Promise], then `handle.evaluate` would wait for the promise to resolve and return its
         value.
-        Examples:
+
+        **Usage**
+
+        ```py
+        tweet_handle = page.query_selector(\".tweet .retweets\")
+        assert tweet_handle.evaluate(\"node => node.innerText\") == \"10 retweets\"
+        ```
 
         Parameters
         ----------
         expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         Any
         """
 
-        try:
-            log_api("=> js_handle.evaluate started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.evaluate(
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= js_handle.evaluate succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.evaluate failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.evaluate(expression=expression, arg=mapping.to_impl(arg))
+            )
+        )
 
     def evaluate_handle(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
+        self, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> "JSHandle":
         """JSHandle.evaluate_handle
 
-        Returns the return value of `pageFunction` as in-page object (JSHandle).
-        This method passes this handle as the first argument to `pageFunction`.
-        The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle` returns
-        in-page object (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.evaluate_handle(pageFunction[, arg]) for more details.
+        Returns the return value of `expression` as a `JSHandle`.
+
+        This method passes this handle as the first argument to `expression`.
+
+        The only difference between `jsHandle.evaluate` and `jsHandle.evaluateHandle` is that `jsHandle.evaluateHandle`
+        returns `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.evaluate_handle()` for more details.
 
         Parameters
         ----------
         expression : str
-            Function to be evaluated
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         JSHandle
         """
 
-        try:
-            log_api("=> js_handle.evaluate_handle started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.evaluateHandle(
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= js_handle.evaluate_handle succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.evaluate_handle failed")
-            raise e
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.evaluate_handle(
+                    expression=expression, arg=mapping.to_impl(arg)
+                )
+            )
+        )
 
     def get_property(self, property_name: str) -> "JSHandle":
         """JSHandle.get_property
@@ -1122,179 +1899,110 @@ def get_property(self, property_name: str) -> "JSHandle":
         JSHandle
         """
 
-        try:
-            log_api("=> js_handle.get_property started")
-            result = mapping.from_impl(
-                self._sync(self._impl_obj.getProperty(propertyName=property_name))
-            )
-            log_api("<= js_handle.get_property succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.get_property failed")
-            raise e
+        return mapping.from_impl(
+            self._sync(self._impl_obj.get_property(propertyName=property_name))
+        )
 
     def get_properties(self) -> typing.Dict[str, "JSHandle"]:
         """JSHandle.get_properties
 
         The method returns a map with **own property names** as keys and JSHandle instances for the property values.
 
+        **Usage**
+
+        ```py
+        handle = page.evaluate_handle(\"({ window, document })\")
+        properties = handle.get_properties()
+        window_handle = properties.get(\"window\")
+        document_handle = properties.get(\"document\")
+        handle.dispose()
+        ```
+
         Returns
         -------
         Dict[str, JSHandle]
         """
 
-        try:
-            log_api("=> js_handle.get_properties started")
-            result = mapping.from_impl_dict(self._sync(self._impl_obj.getProperties()))
-            log_api("<= js_handle.get_properties succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.get_properties failed")
-            raise e
-
-    def as_element(self) -> typing.Union["ElementHandle", NoneType]:
+        return mapping.from_impl_dict(self._sync(self._impl_obj.get_properties()))
+
+    def as_element(self) -> typing.Optional["ElementHandle"]:
         """JSHandle.as_element
 
-        Returns either `null` or the object handle itself, if the object handle is an instance of ElementHandle.
+        Returns either `null` or the object handle itself, if the object handle is an instance of `ElementHandle`.
 
         Returns
         -------
-        Optional[ElementHandle]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> js_handle.as_element started")
-            result = mapping.from_impl_nullable(self._impl_obj.asElement())
-            log_api("<= js_handle.as_element succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.as_element failed")
-            raise e
-
-    def dispose(self) -> NoneType:
+        return mapping.from_impl_nullable(self._impl_obj.as_element())
+
+    def dispose(self) -> None:
         """JSHandle.dispose
 
         The `jsHandle.dispose` method stops referencing the element handle.
         """
 
-        try:
-            log_api("=> js_handle.dispose started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.dispose()))
-            log_api("<= js_handle.dispose succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.dispose failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.dispose()))
 
     def json_value(self) -> typing.Any:
         """JSHandle.json_value
 
-        Returns a JSON representation of the object. If the object has a
-        `toJSON`
-        function, it **will not be called**.
+        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.
+        **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.
 
         Returns
         -------
         Any
         """
 
-        try:
-            log_api("=> js_handle.json_value started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.jsonValue()))
-            log_api("<= js_handle.json_value succeded")
-            return result
-        except Exception as e:
-            log_api("<= js_handle.json_value failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.json_value()))
 
 
 mapping.register(JSHandleImpl, JSHandle)
 
 
 class ElementHandle(JSHandle):
-    def __init__(self, obj: ElementHandleImpl):
-        super().__init__(obj)
-
-    def to_string(self) -> str:
-        """ElementHandle.to_string
 
-        Returns
-        -------
-        str
-        """
-
-        try:
-            log_api("=> element_handle.to_string started")
-            result = mapping.from_maybe_impl(self._impl_obj.toString())
-            log_api("<= element_handle.to_string succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.to_string failed")
-            raise e
-
-    def as_element(self) -> typing.Union["ElementHandle", NoneType]:
+    def as_element(self) -> typing.Optional["ElementHandle"]:
         """ElementHandle.as_element
 
-        Returns either `null` or the object handle itself, if the object handle is an instance of ElementHandle.
+        Returns either `null` or the object handle itself, if the object handle is an instance of `ElementHandle`.
 
         Returns
         -------
-        Optional[ElementHandle]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> element_handle.as_element started")
-            result = mapping.from_impl_nullable(self._impl_obj.asElement())
-            log_api("<= element_handle.as_element succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.as_element failed")
-            raise e
-
-    def owner_frame(self) -> typing.Union["Frame", NoneType]:
+        return mapping.from_impl_nullable(self._impl_obj.as_element())
+
+    def owner_frame(self) -> typing.Optional["Frame"]:
         """ElementHandle.owner_frame
 
         Returns the frame containing the given element.
 
         Returns
         -------
-        Optional[Frame]
+        Union[Frame, None]
         """
 
-        try:
-            log_api("=> element_handle.owner_frame started")
-            result = mapping.from_impl_nullable(self._sync(self._impl_obj.ownerFrame()))
-            log_api("<= element_handle.owner_frame succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.owner_frame failed")
-            raise e
-
-    def content_frame(self) -> typing.Union["Frame", NoneType]:
+        return mapping.from_impl_nullable(self._sync(self._impl_obj.owner_frame()))
+
+    def content_frame(self) -> typing.Optional["Frame"]:
         """ElementHandle.content_frame
 
         Returns the content frame for element handles referencing iframe nodes, or `null` otherwise
 
         Returns
         -------
-        Optional[Frame]
+        Union[Frame, None]
         """
 
-        try:
-            log_api("=> element_handle.content_frame started")
-            result = mapping.from_impl_nullable(
-                self._sync(self._impl_obj.contentFrame())
-            )
-            log_api("<= element_handle.content_frame succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.content_frame failed")
-            raise e
+        return mapping.from_impl_nullable(self._sync(self._impl_obj.content_frame()))
 
-    def get_attribute(self, name: str) -> typing.Union[str, NoneType]:
+    def get_attribute(self, name: str) -> typing.Optional[str]:
         """ElementHandle.get_attribute
 
         Returns element attribute value.
@@ -1306,38 +2014,24 @@ def get_attribute(self, name: str) -> typing.Union[str, NoneType]:
 
         Returns
         -------
-        Optional[str]
+        Union[str, None]
         """
 
-        try:
-            log_api("=> element_handle.get_attribute started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.getAttribute(name=name))
-            )
-            log_api("<= element_handle.get_attribute succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.get_attribute failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.get_attribute(name=name))
+        )
 
-    def text_content(self) -> typing.Union[str, NoneType]:
+    def text_content(self) -> typing.Optional[str]:
         """ElementHandle.text_content
 
         Returns the `node.textContent`.
 
         Returns
         -------
-        Optional[str]
+        Union[str, None]
         """
 
-        try:
-            log_api("=> element_handle.text_content started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.textContent()))
-            log_api("<= element_handle.text_content succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.text_content failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.text_content()))
 
     def inner_text(self) -> str:
         """ElementHandle.inner_text
@@ -1349,14 +2043,7 @@ def inner_text(self) -> str:
         str
         """
 
-        try:
-            log_api("=> element_handle.inner_text started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.innerText()))
-            log_api("<= element_handle.inner_text succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.inner_text failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.inner_text()))
 
     def inner_html(self) -> str:
         """ElementHandle.inner_html
@@ -1368,1058 +2055,1311 @@ def inner_html(self) -> str:
         str
         """
 
-        try:
-            log_api("=> element_handle.inner_html started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.innerHTML()))
-            log_api("<= element_handle.inner_html succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.inner_html failed")
-            raise e
-
-    def dispatch_event(self, type: str, event_init: typing.Dict = None) -> NoneType:
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.inner_html()))
+
+    def is_checked(self) -> bool:
+        """ElementHandle.is_checked
+
+        Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.is_checked()))
+
+    def is_disabled(self) -> bool:
+        """ElementHandle.is_disabled
+
+        Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability#enabled).
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.is_disabled()))
+
+    def is_editable(self) -> bool:
+        """ElementHandle.is_editable
+
+        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.is_editable()))
+
+    def is_enabled(self) -> bool:
+        """ElementHandle.is_enabled
+
+        Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.is_enabled()))
+
+    def is_hidden(self) -> bool:
+        """ElementHandle.is_hidden
+
+        Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability#visible).
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.is_hidden()))
+
+    def is_visible(self) -> bool:
+        """ElementHandle.is_visible
+
+        Returns whether the element is [visible](https://playwright.dev/python/docs/actionability#visible).
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.is_visible()))
+
+    def dispatch_event(
+        self, type: str, event_init: typing.Optional[typing.Dict] = None
+    ) -> None:
         """ElementHandle.dispatch_event
 
-        The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the elment, `click`
-        is dispatched. This is equivalend to calling
-        element.click().
-        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
-        and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
-        Since `eventInit` is event-specific, please refer to the events documentation for the lists of initial properties:
+        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**
+
+        ```py
+        element_handle.dispatch_event(\"click\")
+        ```
 
-        DragEvent
-        FocusEvent
-        KeyboardEvent
-        MouseEvent
-        PointerEvent
-        TouchEvent
-        Event
+        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit`
+        properties and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
+
+        Since `eventInit` 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:
 
+        ```py
+        # note you can only create data_transfer in chromium and firefox
+        data_transfer = page.evaluate_handle(\"new DataTransfer()\")
+        element_handle.dispatch_event(\"#source\", \"dragstart\", {\"dataTransfer\": data_transfer})
+        ```
+
         Parameters
         ----------
         type : str
             DOM event type: `"click"`, `"dragstart"`, etc.
-        event_init : Optional[Dict]
+        event_init : Union[Dict, None]
             Optional event-specific initialization properties.
         """
 
-        try:
-            log_api("=> element_handle.dispatch_event started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.dispatchEvent(
-                        type=type, eventInit=mapping.to_impl(event_init)
-                    )
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.dispatch_event(
+                    type=type, eventInit=mapping.to_impl(event_init)
                 )
             )
-            log_api("<= element_handle.dispatch_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.dispatch_event failed")
-            raise e
+        )
 
-    def scroll_into_view_if_needed(self, timeout: int = None) -> NoneType:
+    def scroll_into_view_if_needed(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
         """ElementHandle.scroll_into_view_if_needed
 
-        This method waits for actionability checks, then tries to scroll element into view, unless it is
-        completely visible as defined by
-        IntersectionObserver's `ratio`.
+        This method waits for [actionability](https://playwright.dev/python/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 to a Document or a ShadowRoot.
+        [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.
+
+        See [scrolling](https://playwright.dev/python/docs/input#scrolling) for alternative ways to scroll.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
         """
 
-        try:
-            log_api("=> element_handle.scroll_into_view_if_needed started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.scrollIntoViewIfNeeded(timeout=timeout))
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.scroll_into_view_if_needed(
+                    timeout=to_milliseconds(timeout)
+                )
             )
-            log_api("<= element_handle.scroll_into_view_if_needed succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.scroll_into_view_if_needed failed")
-            raise e
+        )
 
     def hover(
         self,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-    ) -> NoneType:
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.hover
 
         This method hovers over the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to hover over the center of the element, or the specified `position`.
 
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.mouse to hover over the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
         Parameters
         ----------
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        """
-
-        try:
-            log_api("=> element_handle.hover started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.hover(
-                        modifiers=modifiers,
-                        position=position,
-                        timeout=timeout,
-                        force=force,
-                    )
-                )
-            )
-            log_api("<= element_handle.hover succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.hover failed")
-            raise e
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.hover(
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    force=force,
+                    trial=trial,
+                )
+            )
+        )
 
     def click(
         self,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        click_count: int = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
         """ElementHandle.click
 
         This method clicks the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to click in the center of the element, or the specified `position`.
+        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
 
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
         Parameters
         ----------
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.click started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.click(
-                        modifiers=modifiers,
-                        position=position,
-                        delay=delay,
-                        button=button,
-                        clickCount=click_count,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= element_handle.click succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.click failed")
-            raise e
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.click(
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    clickCount=click_count,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
+                    steps=steps,
+                )
+            )
+        )
 
     def dblclick(
         self,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
         """ElementHandle.dblclick
 
         This method double clicks the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to double click in the center of the element, or the specified `position`.
 
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.mouse to double click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if the first click of the `dblclick()` triggers a navigation event, this method will reject.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
-        **NOTE** `element_handle.dblclick()` dispatches two `click` events and a single `dblclick` event.
+        **NOTE** `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.
 
         Parameters
         ----------
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.dblclick started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.dblclick(
-                        modifiers=modifiers,
-                        position=position,
-                        delay=delay,
-                        button=button,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= element_handle.dblclick succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.dblclick failed")
-            raise e
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.dblclick(
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
+                    steps=steps,
+                )
+            )
+        )
 
     def select_option(
         self,
-        value: typing.Union[str, typing.List[str]] = None,
-        index: typing.Union[int, typing.List[int]] = None,
-        label: typing.Union[str, typing.List[str]] = None,
-        element: typing.Union["ElementHandle", typing.List["ElementHandle"]] = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
+        value: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        *,
+        index: typing.Optional[typing.Union[int, typing.Sequence[int]]] = None,
+        label: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        element: typing.Optional[
+            typing.Union["ElementHandle", typing.Sequence["ElementHandle"]]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
     ) -> typing.List[str]:
         """ElementHandle.select_option
 
+        This method waits for [actionability](https://playwright.dev/python/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. If element is not a `<select>`
-        element, the method throws an error.
+
+        Triggers a `change` and `input` event once all the provided options have been selected.
+
+        **Usage**
+
+        ```py
+        # Single selection matching the value or label
+        handle.select_option(\"blue\")
+        # single selection matching both the label
+        handle.select_option(label=\"blue\")
+        # multiple selection
+        handle.select_option(value=[\"red\", \"green\", \"blue\"])
+        ```
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
+        value : Union[Sequence[str], str, None]
+            Options to select by value. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        index : Union[Sequence[int], int, None]
+            Options to select by index. Optional.
+        label : Union[Sequence[str], str, None]
+            Options to select by label. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        element : Union[ElementHandle, Sequence[ElementHandle], None]
+            Option elements to select. Optional.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
 
         Returns
         -------
         List[str]
         """
 
-        try:
-            log_api("=> element_handle.select_option started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.selectOption(
-                        value=value,
-                        index=index,
-                        label=label,
-                        element=mapping.to_impl(element),
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= element_handle.select_option succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.select_option failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.select_option(
+                    value=mapping.to_impl(value),
+                    index=mapping.to_impl(index),
+                    label=mapping.to_impl(label),
+                    element=mapping.to_impl(element),
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                )
+            )
+        )
 
     def tap(
         self,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.tap
 
         This method taps the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.touchscreen` to tap the center of the element, or the specified `position`.
 
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.touchscreen to tap in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
-        **NOTE** `element_handle.tap()` requires that the `hasTouch` option of the browser context be set to true.
+        **NOTE** `elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.
 
         Parameters
         ----------
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.tap started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.tap(
-                        modifiers=modifiers,
-                        position=position,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= element_handle.tap succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.tap failed")
-            raise e
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.tap(
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
+                )
+            )
+        )
 
     def fill(
-        self, value: str, timeout: int = None, no_wait_after: bool = None
-    ) -> NoneType:
+        self,
+        value: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.fill
 
-        This method waits for actionability checks, focuses the element, fills it and triggers an `input`
-        event after filling. If the element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws
-        an error. Note that you can pass an empty string to clear the input field.
+        This method waits for [actionability](https://playwright.dev/python/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.press_sequentially()`.
 
         Parameters
         ----------
         value : str
             Value to set for the `<input>`, `<textarea>` or `[contenteditable]` element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.fill started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.fill(
-                        value=value, timeout=timeout, noWaitAfter=no_wait_after
-                    )
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.fill(
+                    value=value,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    force=force,
                 )
             )
-            log_api("<= element_handle.fill succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.fill failed")
-            raise e
+        )
 
-    def select_text(self, timeout: int = None) -> NoneType:
+    def select_text(
+        self,
+        *,
+        force: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
         """ElementHandle.select_text
 
-        This method waits for actionability checks, then focuses the element and selects all its text
-        content.
+        This method waits for [actionability](https://playwright.dev/python/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.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
         """
 
-        try:
-            log_api("=> element_handle.select_text started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.selectText(timeout=timeout))
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.select_text(
+                    force=force, timeout=to_milliseconds(timeout)
+                )
             )
-            log_api("<= element_handle.select_text succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.select_text failed")
-            raise e
+        )
+
+    def input_value(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """ElementHandle.input_value
+
+        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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.input_value(timeout=to_milliseconds(timeout)))
+        )
 
     def set_input_files(
         self,
         files: typing.Union[
             str,
             pathlib.Path,
-            "FilePayload",
-            typing.List[str],
-            typing.List[pathlib.Path],
-            typing.List["FilePayload"],
+            FilePayload,
+            typing.Sequence[typing.Union[str, pathlib.Path]],
+            typing.Sequence[FilePayload],
         ],
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.set_input_files
 
-        This method expects `elementHandle` to point to an input
-        element.
-        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.
+        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` 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.
 
         Parameters
         ----------
-        files : Union[str, pathlib.Path, Dict, List[str], List[pathlib.Path], List[Dict]]
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.set_input_files started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.setInputFiles(
-                        files=files, timeout=timeout, noWaitAfter=no_wait_after
-                    )
+        files : Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}]
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_input_files(
+                    files=mapping.to_impl(files),
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
                 )
             )
-            log_api("<= element_handle.set_input_files succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.set_input_files failed")
-            raise e
+        )
 
-    def focus(self) -> NoneType:
+    def focus(self) -> None:
         """ElementHandle.focus
 
-        Calls focus on the element.
+        Calls [focus](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the element.
         """
 
-        try:
-            log_api("=> element_handle.focus started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.focus()))
-            log_api("<= element_handle.focus succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.focus failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.focus()))
 
     def type(
         self,
         text: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.type
 
-        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 element_handle.press(key[, options]).
-        An example of typing into a text field and then submitting the form:
+        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 `element_handle.press()`.
+
+        **Usage**
 
         Parameters
         ----------
         text : str
             A text to type into a focused element.
-        delay : Optional[int]
+        delay : Union[float, None]
             Time to wait between key presses in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.type started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.type(
-                        text=text,
-                        delay=delay,
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= element_handle.type succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.type failed")
-            raise e
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.type(
+                    text=text,
+                    delay=delay,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                )
+            )
+        )
 
     def press(
         self,
         key: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.press
 
-        Focuses the element, and then uses keyboard.down(key) and keyboard.up(key).
-        `key` can specify the intended keyboardEvent.key
-        value or a single character to generate the text for. A superset of the `key` values can be found
-        here. Examples of the keys are:
+        Focuses the element, and then uses `keyboard.down()` and `keyboard.up()`.
+
+        `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` 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 suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
+        `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` in the upper case.
+
         If `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"` or `key: "Control+Shift+T"` are supported as well. When speficied with the
-        modifier, modifier is pressed and being held while the subsequent key is being pressed.
+
+        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.
 
         Parameters
         ----------
         key : str
             Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
-        delay : Optional[int]
+        delay : Union[float, None]
             Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.press(
+                    key=key,
+                    delay=delay,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                )
+            )
+        )
 
-        try:
-            log_api("=> element_handle.press started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.press(
-                        key=key, delay=delay, timeout=timeout, noWaitAfter=no_wait_after
-                    )
+    def set_checked(
+        self,
+        checked: bool,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """ElementHandle.set_checked
+
+        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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        checked : bool
+            Whether to check or uncheck the checkbox.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_checked(
+                    checked=checked,
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
                 )
             )
-            log_api("<= element_handle.press succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.press failed")
-            raise e
+        )
 
     def check(
-        self, timeout: int = None, force: bool = None, no_wait_after: bool = None
-    ) -> NoneType:
+        self,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.check
 
         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/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to click in the center of the element.
+        1. Ensure that the element is now checked. If not, this method throws.
 
-        Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already checked, this method returns immediately.
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now checked. If not, this method rejects.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.check started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.check(
-                        timeout=timeout, force=force, noWaitAfter=no_wait_after
-                    )
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.check(
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
                 )
             )
-            log_api("<= element_handle.check succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.check failed")
-            raise e
+        )
 
     def uncheck(
-        self, timeout: int = None, force: bool = None, no_wait_after: bool = None
-    ) -> NoneType:
+        self,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
         """ElementHandle.uncheck
 
         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/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to click in the center of the element.
+        1. Ensure that the element is now unchecked. If not, this method throws.
 
-        Ensure that element is a checkbox or a radio input. If not, this method rejects. If the element is already unchecked, this method returns immediately.
-        Wait for actionability checks on the element, unless `force` option is set.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now unchecked. If not, this method rejects.
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        If the element is detached from the DOM at any moment during the action, this method rejects.
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> element_handle.uncheck started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.uncheck(
-                        timeout=timeout, force=force, noWaitAfter=no_wait_after
-                    )
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.uncheck(
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
                 )
             )
-            log_api("<= element_handle.uncheck succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.uncheck failed")
-            raise e
+        )
 
-    def bounding_box(self) -> typing.Union["FloatRect", NoneType]:
+    def bounding_box(self) -> typing.Optional[FloatRect]:
         """ElementHandle.bounding_box
 
         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 bonding box, similarly to
-        Element.getBoundingClientRect. That
-        means `x` and/or `y` may be negative.
+
+        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.
-        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.
+        [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**
+
+        ```py
+        box = element_handle.bounding_box()
+        page.mouse.click(box[\"x\"] + box[\"width\"] / 2, box[\"y\"] + box[\"height\"] / 2)
+        ```
 
         Returns
         -------
-        Optional[{"x": float, "y": float, "width": float, "height": float}]
+        Union[{x: float, y: float, width: float, height: float}, None]
         """
 
-        try:
-            log_api("=> element_handle.bounding_box started")
-            result = mapping.from_impl_nullable(
-                self._sync(self._impl_obj.boundingBox())
-            )
-            log_api("<= element_handle.bounding_box succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.bounding_box failed")
-            raise e
+        return mapping.from_impl_nullable(self._sync(self._impl_obj.bounding_box()))
 
     def screenshot(
         self,
-        timeout: int = None,
-        type: Literal["jpeg", "png"] = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        quality: int = None,
-        omit_background: bool = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        type: typing.Optional[Literal["jpeg", "png"]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+        omit_background: typing.Optional[bool] = None,
+        animations: typing.Optional[Literal["allow", "disabled"]] = None,
+        caret: typing.Optional[Literal["hide", "initial"]] = None,
+        scale: typing.Optional[Literal["css", "device"]] = None,
+        mask: typing.Optional[typing.Sequence["Locator"]] = None,
+        mask_color: typing.Optional[str] = None,
+        style: typing.Optional[str] = None,
     ) -> bytes:
         """ElementHandle.screenshot
 
+        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/python/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.
-        This method waits for the actionability checks, then scrolls element into view before taking a
-        screenshot. If the element is detached from DOM, the method throws an error.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        type : Optional[Literal['jpeg', 'png']]
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        type : Union["jpeg", "png", None]
             Specify screenshot type, defaults to `png`.
-        path : Union[str, pathlib.Path, NoneType]
-            The file path to save the image to. The screenshot type will be inferred from file extension. If `path` is a relative path, then it is resolved relative to current working directory. If no path is provided, the image won't be saved to the disk.
-        quality : Optional[int]
+        path : Union[pathlib.Path, str, None]
+            The file path to save the image to. The screenshot type will be inferred from file extension. If `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.
+        quality : Union[int, None]
             The quality of the image, between 0-100. Not applicable to `png` images.
-        omit_background : Optional[bool]
-            Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images. Defaults to `false`.
+        omit_background : Union[bool, None]
+            Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.
+            Defaults to `false`.
+        animations : Union["allow", "disabled", None]
+            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.
+        caret : Union["hide", "initial", None]
+            When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be
+            changed.  Defaults to `"hide"`.
+        scale : Union["css", "device", None]
+            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"`.
+        mask : Union[Sequence[Locator], None]
+            Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
+        mask_color : Union[str, None]
+            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`.
+        style : Union[str, None]
+            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.
 
         Returns
         -------
         bytes
         """
 
-        try:
-            log_api("=> element_handle.screenshot started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.screenshot(
-                        timeout=timeout,
-                        type=type,
-                        path=path,
-                        quality=quality,
-                        omitBackground=omit_background,
-                    )
-                )
-            )
-            log_api("<= element_handle.screenshot succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.screenshot failed")
-            raise e
-
-    def query_selector(self, selector: str) -> typing.Union["ElementHandle", NoneType]:
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.screenshot(
+                    timeout=to_milliseconds(timeout),
+                    type=type,
+                    path=path,
+                    quality=quality,
+                    omitBackground=omit_background,
+                    animations=animations,
+                    caret=caret,
+                    scale=scale,
+                    mask=mapping.to_impl(mask),
+                    maskColor=mask_color,
+                    style=style,
+                )
+            )
+        )
+
+    def query_selector(self, selector: str) -> typing.Optional["ElementHandle"]:
         """ElementHandle.query_selector
 
-        The method finds an element matching the specified selector in the `ElementHandle`'s subtree. See Working with
-        selectors for more details. If no elements match the selector, the return value resolves to
-        `null`.
+        The method finds an element matching the specified selector in the `ElementHandle`'s subtree. If no elements match
+        the selector, returns `null`.
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
+            A selector to query for.
 
         Returns
         -------
-        Optional[ElementHandle]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> element_handle.query_selector started")
-            result = mapping.from_impl_nullable(
-                self._sync(self._impl_obj.querySelector(selector=selector))
-            )
-            log_api("<= element_handle.query_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.query_selector failed")
-            raise e
+        return mapping.from_impl_nullable(
+            self._sync(self._impl_obj.query_selector(selector=selector))
+        )
 
     def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         """ElementHandle.query_selector_all
 
-        The method finds all elements matching the specified selector in the `ElementHandle`s subtree. See Working with
-        selectors for more details. If no elements match the selector, the return value resolves to
-        `[]`.
+        The method finds all elements matching the specified selector in the `ElementHandle`s subtree. If no elements match
+        the selector, returns empty array.
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
+            A selector to query for.
 
         Returns
         -------
         List[ElementHandle]
         """
 
-        try:
-            log_api("=> element_handle.query_selector_all started")
-            result = mapping.from_impl_list(
-                self._sync(self._impl_obj.querySelectorAll(selector=selector))
-            )
-            log_api("<= element_handle.query_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.query_selector_all failed")
-            raise e
+        return mapping.from_impl_list(
+            self._sync(self._impl_obj.query_selector_all(selector=selector))
+        )
 
     def eval_on_selector(
-        self,
-        selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
+        self, selector: str, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> typing.Any:
         """ElementHandle.eval_on_selector
 
-        Returns the return value of `pageFunction`
-        The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a first
-        argument to `pageFunction`. See Working with selectors for more details. If no elements match
-        the selector, the method throws an error.
-        If `pageFunction` returns a Promise, then `frame.$eval` would wait for the promise to resolve and return its value.
-        Examples:
+        Returns the return value of `expression`.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+        The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a
+        first argument to `expression`. If no elements match the selector, the method throws an error.
+
+        If `expression` returns a [Promise], then `element_handle.eval_on_selector()` would wait for the promise to
+        resolve and return its value.
+
+        **Usage**
+
+        ```py
+        tweet_handle = page.query_selector(\".tweet\")
+        assert tweet_handle.eval_on_selector(\".like\", \"node => node.innerText\") == \"100\"
+        assert tweet_handle.eval_on_selector(\".retweets\", \"node => node.innerText\") == \"10\"
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         Any
         """
 
-        try:
-            log_api("=> element_handle.eval_on_selector started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.evalOnSelector(
-                        selector=selector,
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= element_handle.eval_on_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.eval_on_selector failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.eval_on_selector(
+                    selector=selector, expression=expression, arg=mapping.to_impl(arg)
+                )
+            )
+        )
 
     def eval_on_selector_all(
-        self,
-        selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
+        self, selector: str, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> typing.Any:
         """ElementHandle.eval_on_selector_all
 
-        Returns the return value of `pageFunction`
-        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`. See Working with selectors for more
-        details.
-        If `pageFunction` returns a Promise, then `frame.$$eval` would wait for the promise to resolve and return its value.
-        Examples:
+        Returns the return value of `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 `expression`.
+
+        If `expression` returns a [Promise], then `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 class=\"feed\">
+          <div class=\"tweet\">Hello!</div>
+          <div class=\"tweet\">Hi!</div>
         </div>
         ```
 
+        ```py
+        feed_handle = page.query_selector(\".feed\")
+        assert feed_handle.eval_on_selector_all(\".tweet\", \"nodes => nodes.map(n => n.innerText)\") == [\"hello!\", \"hi!\"]
+        ```
+
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
+            A selector to query for.
         expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         Any
         """
 
-        try:
-            log_api("=> element_handle.eval_on_selector_all started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.evalOnSelectorAll(
-                        selector=selector,
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= element_handle.eval_on_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.eval_on_selector_all failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.eval_on_selector_all(
+                    selector=selector, expression=expression, arg=mapping.to_impl(arg)
+                )
+            )
+        )
 
     def wait_for_element_state(
         self,
-        state: Literal["disabled", "enabled", "hidden", "stable", "visible"],
-        timeout: int = None,
-    ) -> NoneType:
+        state: Literal[
+            "disabled", "editable", "enabled", "hidden", "stable", "visible"
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
         """ElementHandle.wait_for_element_state
 
-        Returns the element satisfies the `state`.
-        Depending on the `state` parameter, this method waits for one of the actionability checks to pass.
-        This method throws when the element is detached while waiting, unless waiting for the `"hidden"` state.
+        Returns when the element satisfies the `state`.
 
-        `"visible"` Wait until the element is visible.
-        `"hidden"` Wait until the element is not visible or not attached. Note that waiting for hidden does not throw when the element detaches.
-        `"stable"` Wait until the element is both visible and stable.
-        `"enabled"` Wait until the element is enabled.
-        `"disabled"` Wait until the element is not enabled.
+        Depending on the `state` parameter, this method waits for one of the [actionability](https://playwright.dev/python/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/python/docs/actionability#visible).
+        - `\"hidden\"` Wait until the element is [not visible](https://playwright.dev/python/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/python/docs/actionability#visible) and
+          [stable](https://playwright.dev/python/docs/actionability#stable).
+        - `\"enabled\"` Wait until the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
+        - `\"disabled\"` Wait until the element is [not enabled](https://playwright.dev/python/docs/actionability#enabled).
+        - `\"editable\"` Wait until the element is [editable](https://playwright.dev/python/docs/actionability#editable).
 
         If the element does not satisfy the condition for the `timeout` milliseconds, this method will throw.
 
         Parameters
         ----------
-        state : Literal['disabled', 'enabled', 'hidden', 'stable', 'visible']
+        state : Union["disabled", "editable", "enabled", "hidden", "stable", "visible"]
             A state to wait for, see below for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
         """
 
-        try:
-            log_api("=> element_handle.wait_for_element_state started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.waitForElementState(state=state, timeout=timeout)
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_element_state(
+                    state=state, timeout=to_milliseconds(timeout)
                 )
             )
-            log_api("<= element_handle.wait_for_element_state succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.wait_for_element_state failed")
-            raise e
+        )
 
     def wait_for_selector(
         self,
         selector: str,
-        state: Literal["attached", "detached", "hidden", "visible"] = None,
-        timeout: int = None,
-    ) -> typing.Union["ElementHandle", NoneType]:
+        *,
+        state: typing.Optional[
+            Literal["attached", "detached", "hidden", "visible"]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> typing.Optional["ElementHandle"]:
         """ElementHandle.wait_for_selector
 
-        Returns element specified by selector satisfies `state` option. Resolves to `null` if waiting for `hidden` or
+        Returns element specified by selector when it satisfies `state` option. Returns `null` if waiting for `hidden` or
         `detached`.
-        Wait for the `selector` relative to the element handle to satisfy `state` option (either appear/disappear from dom, or
-        become visible/hidden). If at the moment of calling the method `selector` already satisfies the condition, the method
-        will return immediately. If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will
-        throw.
-
-        **NOTE** This method does not work across navigations, use page.wait_for_selector(selector[, options]) instead.
-
-        Parameters
-        ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-        state : Optional[Literal['attached', 'detached', 'hidden', 'visible']]
-            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.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-
-        Returns
-        -------
-        Optional[ElementHandle]
-        """
-
-        try:
-            log_api("=> element_handle.wait_for_selector started")
-            result = mapping.from_impl_nullable(
-                self._sync(
-                    self._impl_obj.waitForSelector(
-                        selector=selector, state=state, timeout=timeout
-                    )
-                )
-            )
-            log_api("<= element_handle.wait_for_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= element_handle.wait_for_selector failed")
-            raise e
-
 
-mapping.register(ElementHandleImpl, ElementHandle)
-
-
-class Accessibility(SyncBase):
-    def __init__(self, obj: AccessibilityImpl):
-        super().__init__(obj)
-
-    def snapshot(
-        self, interesting_only: bool = None, root: "ElementHandle" = None
-    ) -> typing.Union[typing.Dict, NoneType]:
-        """Accessibility.snapshot
+        Wait for the `selector` relative to the element handle to satisfy `state` option (either appear/disappear from dom,
+        or become visible/hidden). If at the moment of calling the method `selector` already satisfies the condition, the
+        method will return immediately. If the selector doesn't satisfy the condition for the `timeout` milliseconds, the
+        function will throw.
 
-        Captures the current state of the accessibility tree. The returned object represents the root accessible node of the
-        page.
+        **Usage**
 
-        **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` is set to `false`.
+        ```py
+        page.set_content(\"<div><span></span></div>\")
+        div = page.query_selector(\"div\")
+        # waiting for the \"span\" selector relative to the div.
+        span = div.wait_for_selector(\"span\", state=\"attached\")
+        ```
 
-        An example of dumping the entire accessibility tree:
-        An example of logging the focused node's name:
+        **NOTE** This method does not work across navigations, use `page.wait_for_selector()` instead.
 
         Parameters
         ----------
-        interesting_only : Optional[bool]
-            Prune uninteresting nodes from the tree. Defaults to `true`.
-        root : Optional[ElementHandle]
-            The root DOM element for the snapshot. Defaults to the whole page.
+        selector : str
+            A selector to query for.
+        state : Union["attached", "detached", "hidden", "visible", None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        strict : Union[bool, None]
+            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.
 
         Returns
         -------
-        Optional[Dict]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> accessibility.snapshot started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.snapshot(
-                        interestingOnly=interesting_only, root=mapping.to_impl(root)
-                    )
+        return mapping.from_impl_nullable(
+            self._sync(
+                self._impl_obj.wait_for_selector(
+                    selector=selector,
+                    state=state,
+                    timeout=to_milliseconds(timeout),
+                    strict=strict,
                 )
             )
-            log_api("<= accessibility.snapshot succeded")
-            return result
-        except Exception as e:
-            log_api("<= accessibility.snapshot failed")
-            raise e
+        )
 
 
-mapping.register(AccessibilityImpl, Accessibility)
+mapping.register(ElementHandleImpl, ElementHandle)
 
 
 class FileChooser(SyncBase):
-    def __init__(self, obj: FileChooserImpl):
-        super().__init__(obj)
 
     @property
     def page(self) -> "Page":
@@ -2445,7 +3385,6 @@ def element(self) -> "ElementHandle":
         """
         return mapping.from_impl(self._impl_obj.element)
 
-    @property
     def is_multiple(self) -> bool:
         """FileChooser.is_multiple
 
@@ -2455,53 +3394,53 @@ def is_multiple(self) -> bool:
         -------
         bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.isMultiple)
+
+        return mapping.from_maybe_impl(self._impl_obj.is_multiple())
 
     def set_files(
         self,
         files: typing.Union[
-            str, "FilePayload", typing.List[str], typing.List["FilePayload"]
+            str,
+            pathlib.Path,
+            FilePayload,
+            typing.Sequence[typing.Union[str, pathlib.Path]],
+            typing.Sequence[FilePayload],
         ],
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
         """FileChooser.set_files
 
-        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.
+        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.
 
         Parameters
         ----------
-        files : Union[str, Dict, List[str], List[Dict]]
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> file_chooser.set_files started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.setFiles(
-                        files=files, timeout=timeout, noWaitAfter=no_wait_after
-                    )
+        files : Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}]
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_files(
+                    files=mapping.to_impl(files),
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
                 )
             )
-            log_api("<= file_chooser.set_files succeded")
-            return result
-        except Exception as e:
-            log_api("<= file_chooser.set_files failed")
-            raise e
+        )
 
 
 mapping.register(FileChooserImpl, FileChooser)
 
 
 class Frame(SyncBase):
-    def __init__(self, obj: FrameImpl):
-        super().__init__(obj)
 
     @property
     def page(self) -> "Page":
@@ -2520,6 +3459,7 @@ def name(self) -> str:
         """Frame.name
 
         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
@@ -2544,16 +3484,16 @@ def url(self) -> str:
         return mapping.from_maybe_impl(self._impl_obj.url)
 
     @property
-    def parent_frame(self) -> typing.Union["Frame", NoneType]:
+    def parent_frame(self) -> typing.Optional["Frame"]:
         """Frame.parent_frame
 
         Parent frame, if any. Detached frames and main frames return `null`.
 
         Returns
         -------
-        Optional[Frame]
+        Union[Frame, None]
         """
-        return mapping.from_impl_nullable(self._impl_obj.parentFrame)
+        return mapping.from_impl_nullable(self._impl_obj.parent_frame)
 
     @property
     def child_frames(self) -> typing.List["Frame"]:
@@ -2563,662 +3503,1001 @@ def child_frames(self) -> typing.List["Frame"]:
         -------
         List[Frame]
         """
-        return mapping.from_impl_list(self._impl_obj.childFrames)
+        return mapping.from_impl_list(self._impl_obj.child_frames)
 
     def goto(
         self,
         url: str,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        referer: str = None,
-    ) -> typing.Union["Response", NoneType]:
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        referer: typing.Optional[str] = None,
+    ) -> typing.Optional["Response"]:
         """Frame.goto
 
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-        last redirect.
-        `frame.goto` will throw an error if:
+        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of
+        the last redirect.
 
-        there's an SSL error (e.g. in case of self-signed certificates).
-        target URL is invalid.
-        the `timeout` is exceeded during navigation.
-        the remote server does not respond or is unreachable.
-        the main resource failed to load.
+        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` is exceeded during navigation.
+        - the remote server does not respond or is unreachable.
+        - the main resource failed to load.
 
-        `frame.goto` 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().
+        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()`.
 
-        **NOTE** `frame.goto` either throws an error or returns a main resource response. The only exceptions are navigation
+        **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.
+
+        **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).
 
         Parameters
         ----------
         url : str
             URL to navigate frame to. The url should include scheme, e.g. `https://`.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
             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'` - consider operation to be finished when there are no network connections for at least `500` ms.
-        referer : Optional[str]
-            Referer header value. If provided it will take preference over the referer header value set by page.setExtraHTTPHeaders(headers).
+            - `'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.
+        referer : Union[str, None]
+            Referer header value. If provided it will take preference over the referer header value set by
+            `page.set_extra_http_headers()`.
 
         Returns
         -------
-        Optional[Response]
+        Union[Response, None]
         """
 
-        try:
-            log_api("=> frame.goto started")
-            result = mapping.from_impl_nullable(
-                self._sync(
-                    self._impl_obj.goto(
-                        url=url, timeout=timeout, waitUntil=wait_until, referer=referer
-                    )
+        return mapping.from_impl_nullable(
+            self._sync(
+                self._impl_obj.goto(
+                    url=url,
+                    timeout=to_milliseconds(timeout),
+                    waitUntil=wait_until,
+                    referer=referer,
                 )
             )
-            log_api("<= frame.goto succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.goto failed")
-            raise e
+        )
 
-    def wait_for_navigation(
+    def expect_navigation(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Frame.wait_for_navigation
+        *,
+        url: typing.Optional[
+            typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]]
+        ] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["Response"]:
+        """Frame.expect_navigation
+
+        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:
+
+        ```py
+        with frame.expect_navigation():
+            frame.click(\"a.delayed-navigation\") # clicking the link will indirectly cause a navigation
+        # Resolves after navigation has finished
+        ```
 
-        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`.
-        This resolves when the frame navigates to a new URL. It is useful for when you run code which will indirectly cause the
-        frame to navigate. Consider this example:
-        **NOTE** Usage of the History API to change the URL is
-        considered a navigation.
+        **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.
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool], NoneType]
-            URL string, URL regex pattern or predicate receiving URL to match while waiting for the navigation.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
+        url : Union[Callable[[str], bool], Pattern[str], str, None]
+            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.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
             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'` - consider operation to be finished when there are no network connections for at least `500` ms.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+            - `'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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
 
         Returns
         -------
-        Optional[Response]
+        EventContextManager[Response]
         """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_navigation(
+                url=self._wrap_handler(url),
+                waitUntil=wait_until,
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
 
-        try:
-            log_api("=> frame.wait_for_navigation started")
-            result = mapping.from_impl_nullable(
-                self._sync(
-                    self._impl_obj.waitForNavigation(
-                        url=self._wrap_handler(url),
-                        waitUntil=wait_until,
-                        timeout=timeout,
-                    )
-                )
-            )
-            log_api("<= frame.wait_for_navigation succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.wait_for_navigation failed")
-            raise e
+    def wait_for_url(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        *,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Frame.wait_for_url
+
+        Waits for the frame to navigate to the given URL.
+
+        **Usage**
+
+        ```py
+        frame.click(\"a.delayed-navigation\") # clicking the link will indirectly cause a navigation
+        frame.wait_for_url(\"**/target.html\")
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            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.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_url(
+                    url=self._wrap_handler(url),
+                    waitUntil=wait_until,
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
 
     def wait_for_load_state(
         self,
-        state: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> NoneType:
+        state: typing.Optional[
+            Literal["domcontentloaded", "load", "networkidle"]
+        ] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
         """Frame.wait_for_load_state
 
-        Returns when the required load state has been reached.
-        This resolves 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.
+        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/python/docs/actionability).
+
+        **Usage**
+
+        ```py
+        frame.click(\"button\") # click triggers navigation.
+        frame.wait_for_load_state() # the promise resolves after \"load\" event.
+        ```
 
         Parameters
         ----------
-        state : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            Load state to wait for, defaults to `load`. If the state has been already reached while loading current document, the method resolves immediately. Optional.
-             - `'load'` - wait for the `load` event to be fired.
-             - `'domcontentloaded'` - wait for the `DOMContentLoaded` event to be fired.
-             - `'networkidle'` - wait until there are no network connections for at least `500` ms.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        """
-
-        try:
-            log_api("=> frame.wait_for_load_state started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.waitForLoadState(state=state, timeout=timeout)
+        state : Union["domcontentloaded", "load", "networkidle", None]
+            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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_load_state(
+                    state=state, timeout=to_milliseconds(timeout)
                 )
             )
-            log_api("<= frame.wait_for_load_state succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.wait_for_load_state failed")
-            raise e
+        )
 
     def frame_element(self) -> "ElementHandle":
         """Frame.frame_element
 
         Returns the `frame` or `iframe` element handle which corresponds to this frame.
-        This is an inverse of element_handle.content_frame(). Note that returned handle actually belongs to the parent frame.
+
+        This is an inverse of `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**
+
+        ```py
+        frame_element = frame.frame_element()
+        content_frame = frame_element.content_frame()
+        assert frame == content_frame
+        ```
+
         Returns
         -------
         ElementHandle
         """
 
-        try:
-            log_api("=> frame.frame_element started")
-            result = mapping.from_impl(self._sync(self._impl_obj.frameElement()))
-            log_api("<= frame.frame_element succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.frame_element failed")
-            raise e
+        return mapping.from_impl(self._sync(self._impl_obj.frame_element()))
 
     def evaluate(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
+        self, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> typing.Any:
         """Frame.evaluate
 
-        Returns the return value of `pageFunction`
-        If the function passed to the `frame.evaluate` returns a Promise, then `frame.evaluate` would wait for the promise to
-        resolve and return its value.
-        If the function passed to the `frame.evaluate` returns a non-Serializable value, then `frame.evaluate` resolves to
-        `undefined`. DevTools Protocol also supports transferring some additional values that are not serializable by `JSON`:
-        `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
+        Returns the return value of `expression`.
+
+        If the function passed to the `frame.evaluate()` returns a [Promise], then `frame.evaluate()` would
+        wait for the promise to resolve and return its value.
+
+        If the function passed to the `frame.evaluate()` returns a non-[Serializable] value, then
+        `frame.evaluate()` returns `undefined`. Playwright also supports transferring some additional values that
+        are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
+
+        **Usage**
+
+        ```py
+        result = frame.evaluate(\"([x, y]) => Promise.resolve(x * y)\", [7, 8])
+        print(result) # prints \"56\"
+        ```
+
         A string can also be passed in instead of a function.
-        ElementHandle instances can be passed as an argument to the `frame.evaluate`:
+
+        ```py
+        print(frame.evaluate(\"1 + 2\")) # prints \"3\"
+        x = 10
+        print(frame.evaluate(f\"1 + {x}\")) # prints \"11\"
+        ```
+
+        `ElementHandle` instances can be passed as an argument to the `frame.evaluate()`:
+
+        ```py
+        body_handle = frame.evaluate(\"document.body\")
+        html = frame.evaluate(\"([body, suffix]) => body.innerHTML + suffix\", [body_handle, \"hello\"])
+        body_handle.dispose()
+        ```
 
         Parameters
         ----------
         expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         Any
         """
 
-        try:
-            log_api("=> frame.evaluate started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.evaluate(
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= frame.evaluate succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.evaluate failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.evaluate(expression=expression, arg=mapping.to_impl(arg))
+            )
+        )
 
     def evaluate_handle(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
+        self, expression: str, arg: typing.Optional[typing.Any] = None
     ) -> "JSHandle":
         """Frame.evaluate_handle
 
-        Returns the return value of `pageFunction` as in-page object (JSHandle).
-        The only difference between `frame.evaluate` and `frame.evaluate_handle` is that `frame.evaluate_handle` returns in-page
-        object (JSHandle).
-        If the function, passed to the `frame.evaluate_handle`, returns a Promise, then `frame.evaluate_handle` would wait for
-        the promise to resolve and return its value.
+        Returns the return value of `expression` as a `JSHandle`.
+
+        The only difference between `frame.evaluate()` and `frame.evaluate_handle()` is that
+        `frame.evaluate_handle()` returns `JSHandle`.
+
+        If the function, passed to the `frame.evaluate_handle()`, returns a [Promise], then
+        `frame.evaluate_handle()` would wait for the promise to resolve and return its value.
+
+        **Usage**
+
+        ```py
+        a_window_handle = frame.evaluate_handle(\"Promise.resolve(window)\")
+        a_window_handle # handle for the window object.
+        ```
+
         A string can also be passed in instead of a function.
-        JSHandle instances can be passed as an argument to the `frame.evaluate_handle`:
+
+        ```py
+        a_handle = page.evaluate_handle(\"document\") # handle for the \"document\"
+        ```
+
+        `JSHandle` instances can be passed as an argument to the `frame.evaluate_handle()`:
+
+        ```py
+        a_handle = page.evaluate_handle(\"document.body\")
+        result_handle = page.evaluate_handle(\"body => body.innerHTML\", a_handle)
+        print(result_handle.json_value())
+        result_handle.dispose()
+        ```
 
         Parameters
         ----------
         expression : str
-            Function to be evaluated in the page context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
 
         Returns
         -------
         JSHandle
         """
 
-        try:
-            log_api("=> frame.evaluate_handle started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.evaluateHandle(
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= frame.evaluate_handle succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.evaluate_handle failed")
-            raise e
-
-    def query_selector(self, selector: str) -> typing.Union["ElementHandle", NoneType]:
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.evaluate_handle(
+                    expression=expression, arg=mapping.to_impl(arg)
+                )
+            )
+        )
+
+    def query_selector(
+        self, selector: str, *, strict: typing.Optional[bool] = None
+    ) -> typing.Optional["ElementHandle"]:
         """Frame.query_selector
 
         Returns the ElementHandle pointing to the frame element.
-        The method finds an element matching the specified selector within the frame. See Working with
-        selectors for more details. If no elements match the selector, the return value resolves to
-        `null`.
+
+        **NOTE** The use of `ElementHandle` is discouraged, use `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`.
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
+            A selector to query for.
+        strict : Union[bool, None]
+            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.
 
         Returns
         -------
-        Optional[ElementHandle]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> frame.query_selector started")
-            result = mapping.from_impl_nullable(
-                self._sync(self._impl_obj.querySelector(selector=selector))
-            )
-            log_api("<= frame.query_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.query_selector failed")
-            raise e
+        return mapping.from_impl_nullable(
+            self._sync(self._impl_obj.query_selector(selector=selector, strict=strict))
+        )
 
     def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
         """Frame.query_selector_all
 
         Returns the ElementHandles pointing to the frame elements.
-        The method finds all elements matching the specified selector within the frame. See Working with
-        selectors for more details. If no elements match the selector, the return value resolves to
-        `[]`.
+
+        **NOTE** The use of `ElementHandle` is discouraged, use `Locator` objects instead.
+
+        The method finds all elements matching the specified selector within the frame. If no elements match the selector,
+        returns empty array.
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
+            A selector to query for.
 
         Returns
         -------
         List[ElementHandle]
         """
 
-        try:
-            log_api("=> frame.query_selector_all started")
-            result = mapping.from_impl_list(
-                self._sync(self._impl_obj.querySelectorAll(selector=selector))
-            )
-            log_api("<= frame.query_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.query_selector_all failed")
-            raise e
+        return mapping.from_impl_list(
+            self._sync(self._impl_obj.query_selector_all(selector=selector))
+        )
 
     def wait_for_selector(
         self,
         selector: str,
-        timeout: int = None,
-        state: Literal["attached", "detached", "hidden", "visible"] = None,
-    ) -> typing.Union["ElementHandle", NoneType]:
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        state: typing.Optional[
+            Literal["attached", "detached", "hidden", "visible"]
+        ] = None,
+    ) -> typing.Optional["ElementHandle"]:
         """Frame.wait_for_selector
 
-        Returns when element specified by selector satisfies `state` option. Resolves to `null` if waiting for `hidden` or
+        Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
         `detached`.
-        Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at
-        the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the
-        selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
+
+        **NOTE** Playwright automatically waits for element to be ready before performing an action. Using `Locator`
+        objects and web-first assertions make the code wait-for-selector-free.
+
+        Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If
+        at the moment of calling the method `selector` already satisfies the condition, the method will return immediately.
+        If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
+
+        **Usage**
+
         This method works across navigations:
 
+        ```py
+        from playwright.sync_api import sync_playwright, Playwright
+
+        def run(playwright: Playwright):
+            chromium = playwright.chromium
+            browser = chromium.launch()
+            page = browser.new_page()
+            for current_url in [\"https://google.com\", \"https://bbc.com\"]:
+                page.goto(current_url, wait_until=\"domcontentloaded\")
+                element = page.main_frame.wait_for_selector(\"img\")
+                print(\"Loaded image: \" + str(element.get_attribute(\"src\")))
+            browser.close()
+
+        with sync_playwright() as playwright:
+            run(playwright)
+        ```
+
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        state : Optional[Literal['attached', 'detached', 'hidden', 'visible']]
+            A selector to query for.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        state : Union["attached", "detached", "hidden", "visible", None]
             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.
+            - `'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.
 
         Returns
         -------
-        Optional[ElementHandle]
+        Union[ElementHandle, None]
         """
 
-        try:
-            log_api("=> frame.wait_for_selector started")
-            result = mapping.from_impl_nullable(
-                self._sync(
-                    self._impl_obj.waitForSelector(
-                        selector=selector, timeout=timeout, state=state
-                    )
+        return mapping.from_impl_nullable(
+            self._sync(
+                self._impl_obj.wait_for_selector(
+                    selector=selector,
+                    strict=strict,
+                    timeout=to_milliseconds(timeout),
+                    state=state,
                 )
             )
-            log_api("<= frame.wait_for_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.wait_for_selector failed")
-            raise e
+        )
 
-    def dispatch_event(
+    def is_checked(
         self,
         selector: str,
-        type: str,
-        event_init: typing.Dict = None,
-        timeout: int = None,
-    ) -> NoneType:
-        """Frame.dispatch_event
-
-        The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the elment, `click`
-        is dispatched. This is equivalend to calling
-        element.click().
-        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
-        and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
-        Since `eventInit` is event-specific, please refer to the events documentation for the lists of initial properties:
-
-        DragEvent
-        FocusEvent
-        KeyboardEvent
-        MouseEvent
-        PointerEvent
-        TouchEvent
-        Event
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Frame.is_checked
 
-        You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
+        Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        type : str
-            DOM event type: `"click"`, `"dragstart"`, etc.
-        event_init : Optional[Dict]
-            Optional event-specific initialization properties.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
         """
 
-        try:
-            log_api("=> frame.dispatch_event started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.dispatchEvent(
-                        selector=selector,
-                        type=type,
-                        eventInit=mapping.to_impl(event_init),
-                        timeout=timeout,
-                    )
-                )
-            )
-            log_api("<= frame.dispatch_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.dispatch_event failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.is_checked(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def eval_on_selector(
+    def is_disabled(
         self,
         selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-    ) -> typing.Any:
-        """Frame.eval_on_selector
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Frame.is_disabled
 
-        Returns the return value of `pageFunction`
-        The method finds an element matching the specified selector within the frame and passes it as a first argument to
-        `pageFunction`. See Working with selectors for more details. If no elements match the
-        selector, the method throws an error.
-        If `pageFunction` returns a Promise, then `frame.$eval` would wait for the promise to resolve and return its value.
-        Examples:
+        Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability#enabled).
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        Any
+        bool
         """
 
-        try:
-            log_api("=> frame.eval_on_selector started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.evalOnSelector(
-                        selector=selector,
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= frame.eval_on_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.eval_on_selector failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.is_disabled(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def eval_on_selector_all(
+    def is_editable(
         self,
         selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-    ) -> typing.Any:
-        """Frame.eval_on_selector_all
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Frame.is_editable
 
-        Returns the return value of `pageFunction`
-        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`. See Working with selectors for more details.
-        If `pageFunction` returns a Promise, then `frame.$$eval` would wait for the promise to resolve and return its value.
-        Examples:
+        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).
 
         Parameters
         ----------
         selector : str
-            A selector to query for. See working with selectors for more details.
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
-
-        Returns
-        -------
-        Any
-        """
-
-        try:
-            log_api("=> frame.eval_on_selector_all started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.evalOnSelectorAll(
-                        selector=selector,
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= frame.eval_on_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.eval_on_selector_all failed")
-            raise e
-
-    def content(self) -> str:
-        """Frame.content
-
-        Gets the full HTML contents of the frame, including the doctype.
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        str
+        bool
         """
 
-        try:
-            log_api("=> frame.content started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.content()))
-            log_api("<= frame.content succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.content failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.is_editable(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def set_content(
+    def is_enabled(
         self,
-        html: str,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-    ) -> NoneType:
-        """Frame.set_content
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Frame.is_enabled
+
+        Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
 
         Parameters
         ----------
-        html : str
-            HTML markup to assign to the page.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
         """
 
-        try:
-            log_api("=> frame.set_content started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.setContent(
-                        html=html, timeout=timeout, waitUntil=wait_until
-                    )
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.is_enabled(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
                 )
             )
-            log_api("<= frame.set_content succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.set_content failed")
-            raise e
+        )
 
-    def is_detached(self) -> bool:
-        """Frame.is_detached
+    def is_hidden(self, selector: str, *, strict: typing.Optional[bool] = None) -> bool:
+        """Frame.is_hidden
 
-        Returns `true` if the frame has been detached, or `false` otherwise.
+        Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability#visible).  `selector` that
+        does not match any elements is considered hidden.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
 
         Returns
         -------
         bool
         """
 
-        try:
-            log_api("=> frame.is_detached started")
-            result = mapping.from_maybe_impl(self._impl_obj.isDetached())
-            log_api("<= frame.is_detached succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.is_detached failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.is_hidden(selector=selector, strict=strict))
+        )
 
-    def add_script_tag(
-        self,
-        url: str = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content: str = None,
-        type: str = None,
-    ) -> "ElementHandle":
-        """Frame.add_script_tag
+    def is_visible(
+        self, selector: str, *, strict: typing.Optional[bool] = None
+    ) -> bool:
+        """Frame.is_visible
 
-        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.
+        Returns whether the element is [visible](https://playwright.dev/python/docs/actionability#visible). `selector` that does not match any elements
+        is considered not visible.
 
         Parameters
         ----------
-        url : Optional[str]
-            URL of a script to be added.
-        path : Union[str, pathlib.Path, NoneType]
-            Path to the JavaScript file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory.
-        content : Optional[str]
-            Raw JavaScript content to be injected into frame.
-        type : Optional[str]
-            Script type. Use 'module' in order to load a Javascript ES6 module. See script for more details.
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
 
         Returns
         -------
-        ElementHandle
+        bool
         """
 
-        try:
-            log_api("=> frame.add_script_tag started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.addScriptTag(
-                        url=url, path=path, content=content, type=type
-                    )
-                )
-            )
-            log_api("<= frame.add_script_tag succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.add_script_tag failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.is_visible(selector=selector, strict=strict))
+        )
+
+    def dispatch_event(
+        self,
+        selector: str,
+        type: str,
+        event_init: typing.Optional[typing.Dict] = None,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Frame.dispatch_event
+
+        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**
+
+        ```py
+        frame.dispatch_event(\"button#submit\", \"click\")
+        ```
+
+        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit`
+        properties and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
+
+        Since `eventInit` 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:
+
+        ```py
+        # note you can only create data_transfer in chromium and firefox
+        data_transfer = frame.evaluate_handle(\"new DataTransfer()\")
+        frame.dispatch_event(\"#source\", \"dragstart\", { \"dataTransfer\": data_transfer })
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        type : str
+            DOM event type: `"click"`, `"dragstart"`, etc.
+        event_init : Union[Dict, None]
+            Optional event-specific initialization properties.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.dispatch_event(
+                    selector=selector,
+                    type=type,
+                    eventInit=mapping.to_impl(event_init),
+                    strict=strict,
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
+
+    def eval_on_selector(
+        self,
+        selector: str,
+        expression: str,
+        arg: typing.Optional[typing.Any] = None,
+        *,
+        strict: typing.Optional[bool] = None,
+    ) -> typing.Any:
+        """Frame.eval_on_selector
+
+        Returns the return value of `expression`.
+
+        The method finds an element matching the specified selector within the frame and passes it as a first argument to
+        `expression`. If no elements match the selector, the method throws an error.
+
+        If `expression` returns a [Promise], then `frame.eval_on_selector()` would wait for the promise to resolve
+        and return its value.
+
+        **Usage**
+
+        ```py
+        search_value = frame.eval_on_selector(\"#search\", \"el => el.value\")
+        preload_href = frame.eval_on_selector(\"link[rel=preload]\", \"el => el.href\")
+        html = frame.eval_on_selector(\".main-container\", \"(e, suffix) => e.outerHTML + suffix\", \"hello\")
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        strict : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.eval_on_selector(
+                    selector=selector,
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    strict=strict,
+                )
+            )
+        )
+
+    def eval_on_selector_all(
+        self, selector: str, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> typing.Any:
+        """Frame.eval_on_selector_all
+
+        Returns the return value of `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 `expression`.
+
+        If `expression` returns a [Promise], then `frame.eval_on_selector_all()` would wait for the promise to resolve
+        and return its value.
+
+        **Usage**
+
+        ```py
+        divs_counts = frame.eval_on_selector_all(\"div\", \"(divs, min) => divs.length >= min\", 10)
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.eval_on_selector_all(
+                    selector=selector, expression=expression, arg=mapping.to_impl(arg)
+                )
+            )
+        )
+
+    def content(self) -> str:
+        """Frame.content
+
+        Gets the full HTML contents of the frame, including the doctype.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.content()))
+
+    def set_content(
+        self,
+        html: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> None:
+        """Frame.set_content
+
+        This method internally calls [document.write()](https://developer.mozilla.org/en-US/docs/Web/API/Document/write),
+        inheriting all its specific characteristics and behaviors.
+
+        Parameters
+        ----------
+        html : str
+            HTML markup to assign to the page.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_content(
+                    html=html, timeout=to_milliseconds(timeout), waitUntil=wait_until
+                )
+            )
+        )
+
+    def is_detached(self) -> bool:
+        """Frame.is_detached
+
+        Returns `true` if the frame has been detached, or `false` otherwise.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.is_detached())
+
+    def add_script_tag(
+        self,
+        *,
+        url: typing.Optional[str] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
+        type: typing.Optional[str] = None,
+    ) -> "ElementHandle":
+        """Frame.add_script_tag
+
+        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.
+
+        Parameters
+        ----------
+        url : Union[str, None]
+            URL of a script to be added.
+        path : Union[pathlib.Path, str, None]
+            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.
+        content : Union[str, None]
+            Raw JavaScript content to be injected into frame.
+        type : Union[str, None]
+            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.
+
+        Returns
+        -------
+        ElementHandle
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.add_script_tag(
+                    url=url, path=path, content=content, type=type
+                )
+            )
+        )
 
     def add_style_tag(
         self,
-        url: str = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content: str = None,
+        *,
+        url: typing.Optional[str] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
     ) -> "ElementHandle":
         """Frame.add_style_tag
 
         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
+
+        Adds a `<link rel=\"stylesheet\">` tag into the page with the desired url or a `<style type=\"text/css\">` tag with the
         content.
 
         Parameters
         ----------
-        url : Optional[str]
+        url : Union[str, None]
             URL of the `<link>` tag.
-        path : Union[str, pathlib.Path, NoneType]
-            Path to the CSS file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory.
-        content : Optional[str]
+        path : Union[pathlib.Path, str, None]
+            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.
+        content : Union[str, None]
             Raw CSS content to be injected into frame.
 
         Returns
@@ -3226,115 +4505,125 @@ def add_style_tag(
         ElementHandle
         """
 
-        try:
-            log_api("=> frame.add_style_tag started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.addStyleTag(url=url, path=path, content=content)
-                )
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.add_style_tag(url=url, path=path, content=content)
             )
-            log_api("<= frame.add_style_tag succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.add_style_tag failed")
-            raise e
+        )
 
     def click(
         self,
         selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        click_count: int = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
         """Frame.click
 
         This method clicks an element matching `selector` by performing the following steps:
-
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to click in the center of the element, or the specified `position`.
+        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> frame.click started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.click(
-                        selector=selector,
-                        modifiers=modifiers,
-                        position=position,
-                        delay=delay,
-                        button=button,
-                        clickCount=click_count,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= frame.click succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.click failed")
-            raise e
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            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.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.click(
+                    selector=selector,
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    clickCount=click_count,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
 
     def dblclick(
         self,
         selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
         """Frame.dblclick
 
         This method double clicks an element matching `selector` by performing the following steps:
-
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to double click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if the first click of the `dblclick()` triggers a navigation event, this method will reject.
-
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to double click in the center of the element, or the specified `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`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
         **NOTE** `frame.dblclick()` dispatches two `click` events and a single `dblclick` event.
@@ -3342,67 +4631,78 @@ def dblclick(
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
             Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
+        button : Union["left", "middle", "right", None]
             Defaults to `left`.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> frame.dblclick started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.dblclick(
-                        selector=selector,
-                        modifiers=modifiers,
-                        position=position,
-                        delay=delay,
-                        button=button,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= frame.dblclick succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.dblclick failed")
-            raise e
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.dblclick(
+                    selector=selector,
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
 
     def tap(
         self,
         selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
         ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
         """Frame.tap
 
         This method taps an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to tap the center of the element, or the specified `position`.
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.touchscreen to tap the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
         Passing zero timeout disables this.
 
         **NOTE** `frame.tap()` requires that the `hasTouch` option of the browser context be set to true.
@@ -3410,5428 +4710,18747 @@ def tap(
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> frame.tap started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.tap(
-                        selector=selector,
-                        modifiers=modifiers,
-                        position=position,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= frame.tap succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.tap failed")
-            raise e
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.tap(
+                    selector=selector,
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
 
     def fill(
-        self, selector: str, value: str, timeout: int = None, no_wait_after: bool = None
-    ) -> NoneType:
+        self,
+        selector: str,
+        value: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> None:
         """Frame.fill
 
-        This method waits for an element matching `selector`, waits for actionability checks, focuses the
-        element, fills it and triggers an `input` event after filling. If the element matching `selector` is not an `<input>`,
-        `<textarea>` or `[contenteditable]` element, this method throws an error. Note that you can pass an empty string to
-        clear the input field.
-        To send fine-grained keyboard events, use frame.type(selector, text[, options]).
+        This method waits for an element matching `selector`, waits for [actionability](https://playwright.dev/python/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.press_sequentially()`.
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
         value : str
             Value to fill for the `<input>`, `<textarea>` or `[contenteditable]` element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> frame.fill started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.fill(
-                        selector=selector,
-                        value=value,
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= frame.fill succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.fill failed")
-            raise e
-
-    def focus(self, selector: str, timeout: int = None) -> NoneType:
-        """Frame.focus
-
-        This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the method
-        waits until a matching element appears in the DOM.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.fill(
+                    selector=selector,
+                    value=value,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    force=force,
+                )
+            )
+        )
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        """
+    def locator(
+        self,
+        selector: str,
+        *,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has: typing.Optional["Locator"] = None,
+        has_not: typing.Optional["Locator"] = None,
+    ) -> "Locator":
+        """Frame.locator
 
-        try:
-            log_api("=> frame.focus started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.focus(selector=selector, timeout=timeout))
-            )
-            log_api("<= frame.focus succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.focus failed")
-            raise e
+        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.
 
-    def text_content(
-        self, selector: str, timeout: int = None
-    ) -> typing.Union[str, NoneType]:
-        """Frame.text_content
+        [Learn more about locators](https://playwright.dev/python/docs/locators).
 
-        Resolves to the `element.textContent`.
+        [Learn more about locators](https://playwright.dev/python/docs/locators).
 
         Parameters
         ----------
         selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+            A selector to use when resolving DOM element.
+        has_text : Union[Pattern[str], str, None]
+            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>`.
+        has_not_text : Union[Pattern[str], str, None]
+            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.
+        has : Union[Locator, None]
+            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`s.
+        has_not : Union[Locator, None]
+            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`s.
 
         Returns
         -------
-        Optional[str]
+        Locator
         """
 
-        try:
-            log_api("=> frame.text_content started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.textContent(selector=selector, timeout=timeout)
-                )
+        return mapping.from_impl(
+            self._impl_obj.locator(
+                selector=selector,
+                hasText=has_text,
+                hasNotText=has_not_text,
+                has=has._impl_obj if has else None,
+                hasNot=has_not._impl_obj if has_not else None,
             )
-            log_api("<= frame.text_content succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.text_content failed")
-            raise e
-
-    def inner_text(self, selector: str, timeout: int = None) -> str:
-        """Frame.inner_text
+        )
 
-        Resolves to the `element.innerText`.
+    def get_by_alt_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Frame.get_by_alt_text
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        Allows locating elements by their alt text.
 
-        Returns
-        -------
-        str
-        """
+        **Usage**
 
-        try:
-            log_api("=> frame.inner_text started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.innerText(selector=selector, timeout=timeout))
-            )
-            log_api("<= frame.inner_text succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.inner_text failed")
-            raise e
+        For example, this method will find the image by alt text \"Playwright logo\":
 
-    def inner_html(self, selector: str, timeout: int = None) -> str:
-        """Frame.inner_html
+        ```html
+        <img alt='Playwright logo'>
+        ```
 
-        Resolves to the `element.innerHTML`.
+        ```py
+        page.get_by_alt_text(\"Playwright logo\").click()
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
 
         Returns
         -------
-        str
+        Locator
         """
 
-        try:
-            log_api("=> frame.inner_html started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.innerHTML(selector=selector, timeout=timeout))
-            )
-            log_api("<= frame.inner_html succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.inner_html failed")
-            raise e
+        return mapping.from_impl(self._impl_obj.get_by_alt_text(text=text, exact=exact))
 
-    def get_attribute(
-        self, selector: str, name: str, timeout: int = None
-    ) -> typing.Union[str, NoneType]:
-        """Frame.get_attribute
+    def get_by_label(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Frame.get_by_label
 
-        Returns element attribute value.
+        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\">
+        ```
+
+        ```py
+        page.get_by_label(\"Username\").fill(\"john\")
+        page.get_by_label(\"Password\").fill(\"secret\")
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        name : str
-            Attribute name to get the value for.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
 
         Returns
         -------
-        Optional[str]
+        Locator
         """
 
-        try:
-            log_api("=> frame.get_attribute started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.getAttribute(
-                        selector=selector, name=name, timeout=timeout
-                    )
-                )
-            )
-            log_api("<= frame.get_attribute succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.get_attribute failed")
-            raise e
+        return mapping.from_impl(self._impl_obj.get_by_label(text=text, exact=exact))
 
-    def hover(
+    def get_by_placeholder(
         self,
-        selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-    ) -> NoneType:
-        """Frame.hover
-
-        This method hovers over an element matching `selector` by performing the following steps:
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Frame.get_by_placeholder
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to hover over the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        Allows locating input elements by the placeholder text.
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        **Usage**
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        """
+        For example, consider the following DOM structure.
 
-        try:
-            log_api("=> frame.hover started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.hover(
-                        selector=selector,
-                        modifiers=modifiers,
-                        position=position,
-                        timeout=timeout,
-                        force=force,
-                    )
-                )
-            )
-            log_api("<= frame.hover succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.hover failed")
-            raise e
+        ```html
+        <input type=\"email\" placeholder=\"name@example.com\" />
+        ```
 
-    def select_option(
-        self,
-        selector: str,
-        value: typing.Union[str, typing.List[str]] = None,
-        index: typing.Union[int, typing.List[int]] = None,
-        label: typing.Union[str, typing.List[str]] = None,
-        element: typing.Union["ElementHandle", typing.List["ElementHandle"]] = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> typing.List[str]:
-        """Frame.select_option
+        You can fill the input after locating it by the placeholder text:
 
-        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. If there's no `<select>` element
-        matching `selector`, the method throws an error.
+        ```py
+        page.get_by_placeholder(\"name@example.com\").fill(\"playwright@microsoft.com\")
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
 
         Returns
         -------
-        List[str]
+        Locator
         """
 
-        try:
-            log_api("=> frame.select_option started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.selectOption(
-                        selector=selector,
-                        value=value,
-                        index=index,
-                        label=label,
-                        element=mapping.to_impl(element),
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= frame.select_option succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.select_option failed")
-            raise e
+        return mapping.from_impl(
+            self._impl_obj.get_by_placeholder(text=text, exact=exact)
+        )
 
-    def set_input_files(
+    def get_by_role(
         self,
-        selector: str,
-        files: typing.Union[
-            str,
-            pathlib.Path,
-            "FilePayload",
-            typing.List[str],
-            typing.List[pathlib.Path],
-            typing.List["FilePayload"],
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
         ],
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.set_input_files
+        *,
+        checked: typing.Optional[bool] = None,
+        disabled: typing.Optional[bool] = None,
+        expanded: typing.Optional[bool] = None,
+        include_hidden: typing.Optional[bool] = None,
+        level: typing.Optional[int] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        pressed: typing.Optional[bool] = None,
+        selected: typing.Optional[bool] = None,
+        exact: typing.Optional[bool] = None,
+        description: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> "Locator":
+        """Frame.get_by_role
+
+        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.
 
-        This method expects `selector` to point to an input
-        element.
-        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.
+        ```html
+        <h3>Sign up</h3>
+        <label>
+          <input type=\"checkbox\" /> Subscribe
+        </label>
+        <br/>
+        <button>Submit</button>
+        ```
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        files : Union[str, pathlib.Path, Dict, List[str], List[pathlib.Path], List[Dict]]
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        You can locate each element by its implicit role:
 
-        try:
-            log_api("=> frame.set_input_files started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.setInputFiles(
-                        selector=selector,
-                        files=files,
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= frame.set_input_files succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.set_input_files failed")
-            raise e
+        ```py
+        expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
 
-    def type(
-        self,
-        selector: str,
-        text: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.type
+        page.get_by_role(\"checkbox\", name=\"Subscribe\").check()
 
-        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]).
-        To press a special key, like `Control` or `ArrowDown`, use keyboard.press(key[, options]).
+        page.get_by_role(\"button\", name=re.compile(\"submit\", re.IGNORECASE)).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.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        text : str
-            A text to type into a focused element.
-        delay : Optional[int]
-            Time to wait between key presses in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        checked : Union[bool, None]
+            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).
+        disabled : Union[bool, None]
+            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).
+
+        expanded : Union[bool, None]
+            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).
+        include_hidden : Union[bool, None]
+            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).
+        level : Union[int, None]
+            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).
+        name : Union[Pattern[str], str, None]
+            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` to control this behavior.
+
+            Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
+        pressed : Union[bool, None]
+            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).
+        selected : Union[bool, None]
+            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).
+        exact : Union[bool, None]
+            Whether `name` and `description` are matched exactly: case-sensitive and whole-string. Defaults to false. Ignored
+            when the value is a regular expression. Note that exact match still trims whitespace.
+        description : Union[Pattern[str], str, None]
+            Option to match the [accessible description](https://w3c.github.io/accname/#dfn-accessible-description). By
+            default, matching is case-insensitive and searches for a substring, use `exact` to control this behavior.
+
+            Learn more about [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
 
-        try:
-            log_api("=> frame.type started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.type(
-                        selector=selector,
-                        text=text,
-                        delay=delay,
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= frame.type succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.type failed")
-            raise e
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_role(
+                role=role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=include_hidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
 
-    def press(
-        self,
-        selector: str,
-        key: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.press
+    def get_by_test_id(
+        self, test_id: typing.Union[str, typing.Pattern[str]]
+    ) -> "Locator":
+        """Frame.get_by_test_id
 
-        `key` can specify the intended keyboardEvent.key
-        value or a single character to generate the text for. A superset of the `key` values can be found
-        here. 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 suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
-        Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
-        If `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"` or `key: "Control+Shift+T"` are supported as well. When speficied with the
-        modifier, modifier is pressed and being held while the subsequent key is being pressed.
+        Locate element by the test id.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        key : str
-            Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
-        delay : Optional[int]
-            Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        **Usage**
 
-        try:
-            log_api("=> frame.press started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.press(
-                        selector=selector,
-                        key=key,
-                        delay=delay,
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= frame.press succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.press failed")
-            raise e
+        Consider the following DOM structure.
 
-    def check(
-        self,
-        selector: str,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.check
+        ```html
+        <button data-testid=\"directions\">Itinéraire</button>
+        ```
 
-        This method checks an element matching `selector` by performing the following steps:
+        You can locate the element by its test id:
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already checked, this method returns immediately.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now checked. If not, this method rejects.
+        ```py
+        page.get_by_test_id(\"directions\").click()
+        ```
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        **Details**
+
+        By default, the `data-testid` attribute is used as a test id. Use `selectors.set_test_id_attribute()` to
+        configure a different test id attribute if necessary.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
+        test_id : Union[Pattern[str], str]
+            Id to locate the element by.
+
+        Returns
+        -------
+        Locator
         """
 
-        try:
-            log_api("=> frame.check started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.check(
-                        selector=selector,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= frame.check succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.check failed")
-            raise e
+        return mapping.from_impl(self._impl_obj.get_by_test_id(testId=test_id))
 
-    def uncheck(
+    def get_by_text(
         self,
-        selector: str,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Frame.uncheck
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Frame.get_by_text
 
-        This method checks an element matching `selector` by performing the following steps:
+        Allows locating elements that contain given text.
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already unchecked, this method returns immediately.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now unchecked. If not, this method rejects.
+        See also `locator.filter()` that allows to match by another criteria, like an accessible role, and then
+        filter by the text content.
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        **Usage**
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        Consider the following DOM structure:
 
-        try:
-            log_api("=> frame.uncheck started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.uncheck(
-                        selector=selector,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= frame.uncheck succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.uncheck failed")
-            raise e
-
-    def wait_for_timeout(self, timeout: int) -> NoneType:
-        """Frame.wait_for_timeout
+        ```html
+        <div>Hello <span>world</span></div>
+        <div>Hello</div>
+        ```
+
+        You can locate by text substring, exact string, or a regular expression:
+
+        ```py
+        # Matches <span>
+        page.get_by_text(\"world\")
+
+        # Matches first <div>
+        page.get_by_text(\"Hello world\")
+
+        # Matches second <div>
+        page.get_by_text(\"Hello\", exact=True)
+
+        # Matches both <div>s
+        page.get_by_text(re.compile(\"Hello\"))
 
-        Returns a promise that resolves after the timeout.
-        Note that `frame.wait_for_timeout()` 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.
+        # Matches second <div>
+        page.get_by_text(re.compile(\"^hello$\", re.IGNORECASE))
+        ```
+
+        **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\">`.
 
         Parameters
         ----------
-        timeout : int
-            A timeout to wait for
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
         """
 
-        try:
-            log_api("=> frame.wait_for_timeout started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.waitForTimeout(timeout=timeout))
-            )
-            log_api("<= frame.wait_for_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.wait_for_timeout failed")
-            raise e
+        return mapping.from_impl(self._impl_obj.get_by_text(text=text, exact=exact))
 
-    def wait_for_function(
+    def get_by_title(
         self,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-        timeout: int = None,
-        polling: typing.Union[int, Literal["raf"]] = None,
-    ) -> "JSHandle":
-        """Frame.wait_for_function
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Frame.get_by_title
+
+        Allows locating elements by their title attribute.
+
+        **Usage**
 
-        Returns when the `pageFunction` returns a truthy value. It resolves to a JSHandle of the truthy value.
-        The `waitForFunction` can be used to observe viewport size change:
+        Consider the following DOM structure.
 
-        To pass an argument from Node.js to the predicate of `frame.wait_for_function` function:
+        ```html
+        <span title='Issues count'>25 issues</span>
+        ```
+
+        You can check the issues count after locating it by the title text:
+
+        ```py
+        expect(page.get_by_title(\"Issues count\")).to_have_text(\"25 issues\")
+        ```
 
         Parameters
         ----------
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
-        timeout : Optional[int]
-            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).
-        polling : Union[int, 'raf', NoneType]
-            If `polling` is `'raf'`, then `pageFunction` is constantly executed in `requestAnimationFrame` callback. If `polling` is a number, then it is treated as an interval in milliseconds at which the function would be executed. Defaults to `raf`.
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
 
         Returns
         -------
-        JSHandle
+        Locator
         """
 
-        try:
-            log_api("=> frame.wait_for_function started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.waitForFunction(
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                        timeout=timeout,
-                        polling=polling,
-                    )
-                )
-            )
-            log_api("<= frame.wait_for_function succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.wait_for_function failed")
-            raise e
+        return mapping.from_impl(self._impl_obj.get_by_title(text=text, exact=exact))
 
-    def title(self) -> str:
-        """Frame.title
+    def frame_locator(self, selector: str) -> "FrameLocator":
+        """Frame.frame_locator
 
-        Returns the page title.
+        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\">`:
+
+        ```py
+        locator = frame.frame_locator(\"#my-iframe\").get_by_text(\"Submit\")
+        locator.click()
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to use when resolving DOM element.
 
         Returns
         -------
-        str
+        FrameLocator
         """
 
-        try:
-            log_api("=> frame.title started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.title()))
-            log_api("<= frame.title succeded")
-            return result
-        except Exception as e:
-            log_api("<= frame.title failed")
-            raise e
+        return mapping.from_impl(self._impl_obj.frame_locator(selector=selector))
 
-    def expect_load_state(
+    def focus(
         self,
-        state: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> EventContextManager[typing.Union["Response", NoneType]]:
-        """Frame.expect_load_state
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Frame.focus
 
-        with page.expect_loadstate() as event_info:
-            page.click("button")
-        value = event_info.value
+        This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the
+        method waits until a matching element appears in the DOM.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        return EventContextManager(
-            self, self._impl_obj.waitForLoadState(state, timeout)
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.focus(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
         )
 
-    def expect_navigation(
+    def text_content(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> EventContextManager[typing.Union["Response", NoneType]]:
-        """Frame.expect_navigation
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Frame.text_content
 
-        with page.expect_navigation() as event_info:
-            page.click("button")
-        value = event_info.value
+        Returns `element.textContent`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        return EventContextManager(
-            self, self._impl_obj.waitForNavigation(url, wait_until, timeout)
-        )
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
+        Returns
+        -------
+        Union[str, None]
+        """
 
-mapping.register(FrameImpl, Frame)
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.text_content(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
+    def inner_text(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Frame.inner_text
 
-class Worker(SyncBase):
-    def __init__(self, obj: WorkerImpl):
-        super().__init__(obj)
+        Returns `element.innerText`.
 
-    @property
-    def url(self) -> str:
-        """Worker.url
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.url)
 
-    def evaluate(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
-    ) -> typing.Any:
-        """Worker.evaluate
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.inner_text(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def inner_html(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Frame.inner_html
 
-        Returns the return value of `pageFunction`
-        If the function passed to the `worker.evaluate` returns a Promise, then `worker.evaluate` would wait for the promise
-        to resolve and return its value.
-        If the function passed to the `worker.evaluate` returns a non-Serializable value, then `worker.evaluate` resolves to
-        `undefined`. DevTools Protocol also supports transferring some additional values that are not serializable by `JSON`:
-        `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
+        Returns `element.innerHTML`.
 
         Parameters
         ----------
-        expression : str
-            Function to be evaluated in the worker context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        Any
+        str
         """
 
-        try:
-            log_api("=> worker.evaluate started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.evaluate(
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= worker.evaluate succeded")
-            return result
-        except Exception as e:
-            log_api("<= worker.evaluate failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.inner_html(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def evaluate_handle(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
-    ) -> "JSHandle":
-        """Worker.evaluate_handle
+    def get_attribute(
+        self,
+        selector: str,
+        name: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Frame.get_attribute
 
-        Returns the return value of `pageFunction` as in-page object (JSHandle).
-        The only difference between `worker.evaluate` and `worker.evaluate_handle` is that `worker.evaluate_handle` returns
-        in-page object (JSHandle).
-        If the function passed to the `worker.evaluate_handle` returns a Promise, then `worker.evaluate_handle` would wait for
-        the promise to resolve and return its value.
+        Returns element attribute value.
 
         Parameters
         ----------
-        expression : str
-            Function to be evaluated in the page context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        name : str
+            Attribute name to get the value for.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        JSHandle
+        Union[str, None]
         """
 
-        try:
-            log_api("=> worker.evaluate_handle started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.evaluateHandle(
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.get_attribute(
+                    selector=selector,
+                    name=name,
+                    strict=strict,
+                    timeout=to_milliseconds(timeout),
                 )
             )
-            log_api("<= worker.evaluate_handle succeded")
-            return result
-        except Exception as e:
-            log_api("<= worker.evaluate_handle failed")
-            raise e
+        )
 
+    def hover(
+        self,
+        selector: str,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.hover
 
-mapping.register(WorkerImpl, Worker)
+        This method hovers over an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to hover over the center of the element, or the specified `position`.
 
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
-class Selectors(SyncBase):
-    def __init__(self, obj: SelectorsImpl):
-        super().__init__(obj)
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.hover(
+                    selector=selector,
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    force=force,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
 
-    def register(
+    def drag_and_drop(
         self,
-        name: str,
-        source: str = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content_script: bool = None,
-    ) -> NoneType:
-        """Selectors.register
-
-        An example of registering selector engine that queries elements based on a tag name:
+        source: str,
+        target: str,
+        *,
+        source_position: typing.Optional[Position] = None,
+        target_position: typing.Optional[Position] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
+        """Frame.drag_and_drop
 
         Parameters
         ----------
-        name : str
-            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.
-        source : Optional[str]
-            Script that evaluates to a selector engine instance.
-        content_script : Optional[bool]
-            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.
-        """
-
-        try:
-            log_api("=> selectors.register started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.register(
-                        name=name,
-                        source=source,
-                        path=path,
-                        contentScript=content_script,
-                    )
+        source : str
+            A selector to search for an element to drag. If there are multiple elements satisfying the selector, the first will
+            be used.
+        target : str
+            A selector to search for an element to drop onto. If there are multiple elements satisfying the selector, the first
+            will be used.
+        source_position : Union[{x: float, y: float}, None]
+            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.
+        target_position : Union[{x: float, y: float}, None]
+            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.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.drag_and_drop(
+                    source=source,
+                    target=target,
+                    sourcePosition=source_position,
+                    targetPosition=target_position,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    timeout=to_milliseconds(timeout),
+                    trial=trial,
+                    steps=steps,
                 )
             )
-            log_api("<= selectors.register succeded")
-            return result
-        except Exception as e:
-            log_api("<= selectors.register failed")
-            raise e
+        )
 
+    def select_option(
+        self,
+        selector: str,
+        value: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        *,
+        index: typing.Optional[typing.Union[int, typing.Sequence[int]]] = None,
+        label: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        element: typing.Optional[
+            typing.Union["ElementHandle", typing.Sequence["ElementHandle"]]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> typing.List[str]:
+        """Frame.select_option
 
-mapping.register(SelectorsImpl, Selectors)
+        This method waits for an element matching `selector`, waits for [actionability](https://playwright.dev/python/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.
 
-class ConsoleMessage(SyncBase):
-    def __init__(self, obj: ConsoleMessageImpl):
-        super().__init__(obj)
+        Returns the array of option values that have been successfully selected.
 
-    @property
-    def type(self) -> str:
-        """ConsoleMessage.type
+        Triggers a `change` and `input` event once all the provided options have been selected.
+
+        **Usage**
 
-        One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`,
-        `'trace'`, `'clear'`, `'startGroup'`, `'startGroupCollapsed'`, `'endGroup'`, `'assert'`, `'profile'`, `'profileEnd'`,
-        `'count'`, `'timeEnd'`.
+        ```py
+        # Single selection matching the value or label
+        frame.select_option(\"select#colors\", \"blue\")
+        # single selection matching both the label
+        frame.select_option(\"select#colors\", label=\"blue\")
+        # multiple selection
+        frame.select_option(\"select#colors\", value=[\"red\", \"green\", \"blue\"])
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        value : Union[Sequence[str], str, None]
+            Options to select by value. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        index : Union[Sequence[int], int, None]
+            Options to select by index. Optional.
+        label : Union[Sequence[str], str, None]
+            Options to select by label. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        element : Union[ElementHandle, Sequence[ElementHandle], None]
+            Option elements to select. Optional.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
 
         Returns
         -------
-        str
+        List[str]
         """
-        return mapping.from_maybe_impl(self._impl_obj.type)
 
-    @property
-    def text(self) -> str:
-        """ConsoleMessage.text
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.select_option(
+                    selector=selector,
+                    value=mapping.to_impl(value),
+                    index=mapping.to_impl(index),
+                    label=mapping.to_impl(label),
+                    element=mapping.to_impl(element),
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    force=force,
+                )
+            )
+        )
+
+    def input_value(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Frame.input_value
+
+        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.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.text)
-
-    @property
-    def args(self) -> typing.List["JSHandle"]:
-        """ConsoleMessage.args
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.input_value(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def set_input_files(
+        self,
+        selector: str,
+        files: typing.Union[
+            str,
+            pathlib.Path,
+            FilePayload,
+            typing.Sequence[typing.Union[str, pathlib.Path]],
+            typing.Sequence[FilePayload],
+        ],
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.set_input_files
+
+        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` 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.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        files : Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}]
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_input_files(
+                    selector=selector,
+                    files=mapping.to_impl(files),
+                    strict=strict,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                )
+            )
+        )
+
+    def type(
+        self,
+        selector: str,
+        text: str,
+        *,
+        delay: typing.Optional[float] = None,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.type
+
+        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()`.
+
+        To press a special key, like `Control` or `ArrowDown`, use `keyboard.press()`.
+
+        **Usage**
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        text : str
+            A text to type into a focused element.
+        delay : Union[float, None]
+            Time to wait between key presses in milliseconds. Defaults to 0.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.type(
+                    selector=selector,
+                    text=text,
+                    delay=delay,
+                    strict=strict,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                )
+            )
+        )
+
+    def press(
+        self,
+        selector: str,
+        key: str,
+        *,
+        delay: typing.Optional[float] = None,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.press
+
+        `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` 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` in the upper case.
+
+        If `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.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        key : str
+            Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
+        delay : Union[float, None]
+            Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.press(
+                    selector=selector,
+                    key=key,
+                    delay=delay,
+                    strict=strict,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                )
+            )
+        )
+
+    def check(
+        self,
+        selector: str,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.check
+
+        This method checks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.check(
+                    selector=selector,
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
+
+    def uncheck(
+        self,
+        selector: str,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.uncheck
+
+        This method checks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.uncheck(
+                    selector=selector,
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
+
+    def wait_for_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """Frame.wait_for_timeout
+
+        Waits for the given `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.
+
+        Parameters
+        ----------
+        timeout : float
+            A timeout to wait for
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_timeout(timeout=to_milliseconds(timeout))
+            )
+        )
+
+    def wait_for_function(
+        self,
+        expression: str,
+        *,
+        arg: typing.Optional[typing.Any] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None,
+    ) -> "JSHandle":
+        """Frame.wait_for_function
+
+        Returns when the `expression` returns a truthy value, returns that value.
+
+        **Usage**
+
+        The `frame.wait_for_function()` can be used to observe viewport size change:
+
+        ```py
+        from playwright.sync_api import sync_playwright, Playwright
+
+        def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = webkit.launch()
+            page = browser.new_page()
+            page.evaluate(\"window.x = 0; setTimeout(() => { window.x = 100 }, 1000);\")
+            page.main_frame.wait_for_function(\"() => window.x > 0\")
+            browser.close()
+
+        with sync_playwright() as playwright:
+            run(playwright)
+        ```
+
+        To pass an argument to the predicate of `frame.waitForFunction` function:
+
+        ```py
+        selector = \".foo\"
+        frame.wait_for_function(\"selector => !!document.querySelector(selector)\", selector)
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()` or
+            `page.set_default_timeout()` methods.
+        polling : Union["raf", float, None]
+            If `polling` is `'raf'`, then `expression` is constantly executed in `requestAnimationFrame` callback. If `polling`
+            is a number, then it is treated as an interval in milliseconds at which the function would be executed. Defaults to
+            `raf`.
+
+        Returns
+        -------
+        JSHandle
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.wait_for_function(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    timeout=to_milliseconds(timeout),
+                    polling=polling,
+                )
+            )
+        )
+
+    def title(self) -> str:
+        """Frame.title
+
+        Returns the page title.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.title()))
+
+    def set_checked(
+        self,
+        selector: str,
+        checked: bool,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Frame.set_checked
+
+        This method checks or unchecks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        checked : bool
+            Whether to check or uncheck the checkbox.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_checked(
+                    selector=selector,
+                    checked=checked,
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
+
+
+mapping.register(FrameImpl, Frame)
+
+
+class FrameLocator(SyncBase):
+
+    @property
+    def first(self) -> "FrameLocator":
+        """FrameLocator.first
+
+        Returns locator to the first matching frame.
+
+        Returns
+        -------
+        FrameLocator
+        """
+        return mapping.from_impl(self._impl_obj.first)
+
+    @property
+    def last(self) -> "FrameLocator":
+        """FrameLocator.last
+
+        Returns locator to the last matching frame.
+
+        Returns
+        -------
+        FrameLocator
+        """
+        return mapping.from_impl(self._impl_obj.last)
+
+    @property
+    def owner(self) -> "Locator":
+        """FrameLocator.owner
+
+        Returns a `Locator` object pointing to the same `iframe` as this frame locator.
+
+        Useful when you have a `FrameLocator` object obtained somewhere, and later on would like to interact with the
+        `iframe` element.
+
+        For a reverse operation, use `locator.content_frame()`.
+
+        **Usage**
+
+        ```py
+        frame_locator = page.locator(\"iframe[name=\\\"embedded\\\"]\").content_frame
+        # ...
+        locator = frame_locator.owner
+        expect(locator).to_be_visible()
+        ```
+
+        Returns
+        -------
+        Locator
+        """
+        return mapping.from_impl(self._impl_obj.owner)
+
+    def locator(
+        self,
+        selector_or_locator: typing.Union["Locator", str],
+        *,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has: typing.Optional["Locator"] = None,
+        has_not: typing.Optional["Locator"] = None,
+    ) -> "Locator":
+        """FrameLocator.locator
+
+        The method finds an element matching the specified selector in the locator's subtree. It also accepts filter
+        options, similar to `locator.filter()` method.
+
+        [Learn more about locators](https://playwright.dev/python/docs/locators).
+
+        Parameters
+        ----------
+        selector_or_locator : Union[Locator, str]
+            A selector or locator to use when resolving DOM element.
+        has_text : Union[Pattern[str], str, None]
+            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>`.
+        has_not_text : Union[Pattern[str], str, None]
+            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.
+        has : Union[Locator, None]
+            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`s.
+        has_not : Union[Locator, None]
+            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`s.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.locator(
+                selectorOrLocator=selector_or_locator,
+                hasText=has_text,
+                hasNotText=has_not_text,
+                has=has._impl_obj if has else None,
+                hasNot=has_not._impl_obj if has_not else None,
+            )
+        )
+
+    def get_by_alt_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_alt_text
+
+        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'>
+        ```
+
+        ```py
+        page.get_by_alt_text(\"Playwright logo\").click()
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_alt_text(text=text, exact=exact))
+
+    def get_by_label(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_label
+
+        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\">
+        ```
+
+        ```py
+        page.get_by_label(\"Username\").fill(\"john\")
+        page.get_by_label(\"Password\").fill(\"secret\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_label(text=text, exact=exact))
+
+    def get_by_placeholder(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_placeholder
+
+        Allows locating input elements by the placeholder text.
+
+        **Usage**
+
+        For example, consider the following DOM structure.
+
+        ```html
+        <input type=\"email\" placeholder=\"name@example.com\" />
+        ```
+
+        You can fill the input after locating it by the placeholder text:
+
+        ```py
+        page.get_by_placeholder(\"name@example.com\").fill(\"playwright@microsoft.com\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_placeholder(text=text, exact=exact)
+        )
+
+    def get_by_role(
+        self,
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
+        ],
+        *,
+        checked: typing.Optional[bool] = None,
+        disabled: typing.Optional[bool] = None,
+        expanded: typing.Optional[bool] = None,
+        include_hidden: typing.Optional[bool] = None,
+        level: typing.Optional[int] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        pressed: typing.Optional[bool] = None,
+        selected: typing.Optional[bool] = None,
+        exact: typing.Optional[bool] = None,
+        description: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_role
+
+        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 its implicit role:
+
+        ```py
+        expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
+
+        page.get_by_role(\"checkbox\", name=\"Subscribe\").check()
+
+        page.get_by_role(\"button\", name=re.compile(\"submit\", re.IGNORECASE)).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.
+
+        Parameters
+        ----------
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        checked : Union[bool, None]
+            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).
+        disabled : Union[bool, None]
+            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).
+
+        expanded : Union[bool, None]
+            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).
+        include_hidden : Union[bool, None]
+            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).
+        level : Union[int, None]
+            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).
+        name : Union[Pattern[str], str, None]
+            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` to control this behavior.
+
+            Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
+        pressed : Union[bool, None]
+            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).
+        selected : Union[bool, None]
+            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).
+        exact : Union[bool, None]
+            Whether `name` and `description` are matched exactly: case-sensitive and whole-string. Defaults to false. Ignored
+            when the value is a regular expression. Note that exact match still trims whitespace.
+        description : Union[Pattern[str], str, None]
+            Option to match the [accessible description](https://w3c.github.io/accname/#dfn-accessible-description). By
+            default, matching is case-insensitive and searches for a substring, use `exact` to control this behavior.
+
+            Learn more about [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_role(
+                role=role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=include_hidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
+
+    def get_by_test_id(
+        self, test_id: typing.Union[str, typing.Pattern[str]]
+    ) -> "Locator":
+        """FrameLocator.get_by_test_id
+
+        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 its test id:
+
+        ```py
+        page.get_by_test_id(\"directions\").click()
+        ```
+
+        **Details**
+
+        By default, the `data-testid` attribute is used as a test id. Use `selectors.set_test_id_attribute()` to
+        configure a different test id attribute if necessary.
+
+        Parameters
+        ----------
+        test_id : Union[Pattern[str], str]
+            Id to locate the element by.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_test_id(testId=test_id))
+
+    def get_by_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_text
+
+        Allows locating elements that contain given text.
+
+        See also `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:
+
+        ```py
+        # Matches <span>
+        page.get_by_text(\"world\")
+
+        # Matches first <div>
+        page.get_by_text(\"Hello world\")
+
+        # Matches second <div>
+        page.get_by_text(\"Hello\", exact=True)
+
+        # Matches both <div>s
+        page.get_by_text(re.compile(\"Hello\"))
+
+        # Matches second <div>
+        page.get_by_text(re.compile(\"^hello$\", re.IGNORECASE))
+        ```
+
+        **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\">`.
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_text(text=text, exact=exact))
+
+    def get_by_title(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """FrameLocator.get_by_title
+
+        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:
+
+        ```py
+        expect(page.get_by_title(\"Issues count\")).to_have_text(\"25 issues\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_title(text=text, exact=exact))
+
+    def frame_locator(self, selector: str) -> "FrameLocator":
+        """FrameLocator.frame_locator
+
+        When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements
+        in that iframe.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to use when resolving DOM element.
+
+        Returns
+        -------
+        FrameLocator
+        """
+
+        return mapping.from_impl(self._impl_obj.frame_locator(selector=selector))
+
+    def nth(self, index: int) -> "FrameLocator":
+        """FrameLocator.nth
+
+        Returns locator to the n-th matching frame. It's zero based, `nth(0)` selects the first frame.
+
+        Parameters
+        ----------
+        index : int
+
+        Returns
+        -------
+        FrameLocator
+        """
+
+        return mapping.from_impl(self._impl_obj.nth(index=index))
+
+
+mapping.register(FrameLocatorImpl, FrameLocator)
+
+
+class Worker(SyncBase):
+
+    @typing.overload
+    def on(
+        self, event: Literal["close"], f: typing.Callable[["Worker"], "None"]
+    ) -> None:
+        """
+        Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is
+        terminated."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
+    ) -> None:
+        """
+        Emitted when JavaScript within the worker calls one of console API methods, e.g. `console.log` or `console.dir`.
+        """
+
+    def on(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self, event: Literal["close"], f: typing.Callable[["Worker"], "None"]
+    ) -> None:
+        """
+        Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is
+        terminated."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
+    ) -> None:
+        """
+        Emitted when JavaScript within the worker calls one of console API methods, e.g. `console.log` or `console.dir`.
+        """
+
+    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def url(self) -> str:
+        """Worker.url
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    def evaluate(
+        self, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> typing.Any:
+        """Worker.evaluate
+
+        Returns the return value of `expression`.
+
+        If the function passed to the `worker.evaluate()` returns a [Promise], then `worker.evaluate()`
+        would wait for the promise to resolve and return its value.
+
+        If the function passed to the `worker.evaluate()` returns a non-[Serializable] value, then
+        `worker.evaluate()` returns `undefined`. Playwright also supports transferring some additional values that
+        are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.evaluate(expression=expression, arg=mapping.to_impl(arg))
+            )
+        )
+
+    def evaluate_handle(
+        self, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> "JSHandle":
+        """Worker.evaluate_handle
+
+        Returns the return value of `expression` as a `JSHandle`.
+
+        The only difference between `worker.evaluate()` and `worker.evaluate_handle()` is that
+        `worker.evaluate_handle()` returns `JSHandle`.
+
+        If the function passed to the `worker.evaluate_handle()` returns a [Promise], then
+        `worker.evaluate_handle()` would wait for the promise to resolve and return its value.
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        JSHandle
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.evaluate_handle(
+                    expression=expression, arg=mapping.to_impl(arg)
+                )
+            )
+        )
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["ConsoleMessage"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager[typing.Any]: ...
+
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager:
+        """Worker.expect_event
+
+        Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+        value. Will throw an error if the page is closed before the event is fired. Returns the event data value.
+
+        **Usage**
+
+        ```py
+        with worker.expect_event(\"console\") as event_info:
+            worker.evaluate(\"console.log(42)\")
+        message = event_info.value
+        ```
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_event(
+                event=event,
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+
+mapping.register(WorkerImpl, Worker)
+
+
+class Selectors(SyncBase):
+
+    def register(
+        self,
+        name: str,
+        script: typing.Optional[str] = None,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content_script: typing.Optional[bool] = None,
+    ) -> None:
+        """Selectors.register
+
+        Selectors must be registered before creating the page.
+
+        **Usage**
+
+        An example of registering selector engine that queries elements based on a tag name:
+
+        ```py
+        from playwright.sync_api import sync_playwright, Playwright
+
+        def run(playwright: Playwright):
+            tag_selector = \"\"\"
+              {
+                  // 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=\".
+            playwright.selectors.register(\"tag\", tag_selector)
+            browser = playwright.chromium.launch()
+            page = browser.new_page()
+            page.set_content('<div><button>Click me</button></div>')
+
+            # Use the selector prefixed with its name.
+            button = page.locator('tag=button')
+            # Combine it with built-in locators.
+            page.locator('tag=div').get_by_text('Click me').click()
+            # Can use it in any methods supporting selectors.
+            button_count = page.locator('tag=button').count()
+            print(button_count)
+            browser.close()
+
+        with sync_playwright() as playwright:
+            run(playwright)
+        ```
+
+        Parameters
+        ----------
+        name : str
+            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.
+        script : Union[str, None]
+            Raw script content.
+        path : Union[pathlib.Path, str, None]
+            Path to the JavaScript file. If `path` is a relative path, then it is resolved relative to the current working
+            directory.
+        content_script : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.register(
+                    name=name, script=script, path=path, contentScript=content_script
+                )
+            )
+        )
+
+    def set_test_id_attribute(self, attribute_name: str) -> None:
+        """Selectors.set_test_id_attribute
+
+        Defines custom attribute name to be used in `page.get_by_test_id()`. `data-testid` is used by default.
+
+        Parameters
+        ----------
+        attribute_name : str
+            Test id attribute name.
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_test_id_attribute(attributeName=attribute_name)
+        )
+
+
+mapping.register(SelectorsImpl, Selectors)
+
+
+class Clock(SyncBase):
+
+    def install(
+        self,
+        *,
+        time: typing.Optional[typing.Union[float, str, datetime.datetime]] = None,
+    ) -> None:
+        """Clock.install
+
+        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.run_for()` and
+        `clock.fast_forward()` for more information.
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str, None]
+            Time to initialize with, current system time by default.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.install(time=time)))
+
+    def fast_forward(self, ticks: typing.Union[int, str]) -> None:
+        """Clock.fast_forward
+
+        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**
+
+        ```py
+        page.clock.fast_forward(1000)
+        page.clock.fast_forward(\"30:00\")
+        ```
+
+        Parameters
+        ----------
+        ticks : Union[int, str]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.fast_forward(ticks=ticks))
+        )
+
+    def pause_at(self, time: typing.Union[float, str, datetime.datetime]) -> None:
+        """Clock.pause_at
+
+        Advance the clock by jumping forward in time and pause the time. Once this method is called, no timers are fired
+        unless `clock.run_for()`, `clock.fast_forward()`, `clock.pause_at()` or
+        `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**
+
+        ```py
+        page.clock.pause_at(datetime.datetime(2020, 2, 2))
+        page.clock.pause_at(\"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.pause_at()` to pause the clock.
+
+        ```py
+        # Initialize clock with some time before the test time and let the page load
+        # naturally. `Date.now` will progress as the timers fire.
+        page.clock.install(time=datetime.datetime(2024, 12, 10, 8, 0, 0))
+        page.goto(\"http://localhost:3333\")
+        page.clock.pause_at(datetime.datetime(2024, 12, 10, 10, 0, 0))
+        ```
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str]
+            Time to pause at.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.pause_at(time=time)))
+
+    def resume(self) -> None:
+        """Clock.resume
+
+        Resumes timers. Once this method is called, time resumes flowing, timers are fired as usual.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.resume()))
+
+    def run_for(self, ticks: typing.Union[int, str]) -> None:
+        """Clock.run_for
+
+        Advance the clock, firing all the time-related callbacks.
+
+        **Usage**
+
+        ```py
+        page.clock.run_for(1000);
+        page.clock.run_for(\"30:00\")
+        ```
+
+        Parameters
+        ----------
+        ticks : Union[int, str]
+            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.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.run_for(ticks=ticks)))
+
+    def set_fixed_time(self, time: typing.Union[float, str, datetime.datetime]) -> None:
+        """Clock.set_fixed_time
+
+        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()` instead. Read docs on [clock emulation](https://playwright.dev/python/docs/clock) to learn more.
+
+        **Usage**
+
+        ```py
+        page.clock.set_fixed_time(datetime.datetime.now())
+        page.clock.set_fixed_time(datetime.datetime(2020, 2, 2))
+        page.clock.set_fixed_time(\"2020-02-02\")
+        ```
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str]
+            Time to be set.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.set_fixed_time(time=time))
+        )
+
+    def set_system_time(
+        self, time: typing.Union[float, str, datetime.datetime]
+    ) -> None:
+        """Clock.set_system_time
+
+        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**
+
+        ```py
+        page.clock.set_system_time(datetime.datetime.now())
+        page.clock.set_system_time(datetime.datetime(2020, 2, 2))
+        page.clock.set_system_time(\"2020-02-02\")
+        ```
+
+        Parameters
+        ----------
+        time : Union[datetime.datetime, float, str]
+            Time to be set.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.set_system_time(time=time))
+        )
+
+
+mapping.register(ClockImpl, Clock)
+
+
+class ConsoleMessage(SyncBase):
+
+    @property
+    def type(
+        self,
+    ) -> typing.Union[
+        Literal["assert"],
+        Literal["clear"],
+        Literal["count"],
+        Literal["debug"],
+        Literal["dir"],
+        Literal["dirxml"],
+        Literal["endGroup"],
+        Literal["error"],
+        Literal["info"],
+        Literal["log"],
+        Literal["profile"],
+        Literal["profileEnd"],
+        Literal["startGroup"],
+        Literal["startGroupCollapsed"],
+        Literal["table"],
+        Literal["time"],
+        Literal["timeEnd"],
+        Literal["trace"],
+        Literal["warning"],
+    ]:
+        """ConsoleMessage.type
+
+        Returns
+        -------
+        Union["assert", "clear", "count", "debug", "dir", "dirxml", "endGroup", "error", "info", "log", "profile", "profileEnd", "startGroup", "startGroupCollapsed", "table", "time", "timeEnd", "trace", "warning"]
+        """
+        return mapping.from_maybe_impl(self._impl_obj.type)
+
+    @property
+    def text(self) -> str:
+        """ConsoleMessage.text
+
+        The text of the console message.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.text)
+
+    @property
+    def args(self) -> typing.List["JSHandle"]:
+        """ConsoleMessage.args
+
+        List of arguments passed to a `console` function call. See also `page.on('console')`.
+
+        Returns
+        -------
+        List[JSHandle]
+        """
+        return mapping.from_impl_list(self._impl_obj.args)
+
+    @property
+    def location(self) -> SourceLocation:
+        """ConsoleMessage.location
+
+        Returns
+        -------
+        {url: str, line: int, column: int, lineNumber: int, columnNumber: int}
+        """
+        return mapping.from_impl(self._impl_obj.location)
+
+    @property
+    def timestamp(self) -> float:
+        """ConsoleMessage.timestamp
+
+        The timestamp of the console message in milliseconds since the Unix epoch.
+
+        Returns
+        -------
+        float
+        """
+        return mapping.from_maybe_impl(self._impl_obj.timestamp)
+
+    @property
+    def page(self) -> typing.Optional["Page"]:
+        """ConsoleMessage.page
+
+        The page that produced this console message, if any.
+
+        Returns
+        -------
+        Union[Page, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.page)
+
+    @property
+    def worker(self) -> typing.Optional["Worker"]:
+        """ConsoleMessage.worker
+
+        The web worker or service worker that produced this console message, if any. Note that console messages from web
+        workers also have non-null `console_message.page()`.
+
+        Returns
+        -------
+        Union[Worker, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.worker)
+
+
+mapping.register(ConsoleMessageImpl, ConsoleMessage)
+
+
+class Debugger(SyncBase):
+
+    @typing.overload
+    def on(
+        self, event: Literal["pausedstatechanged"], f: typing.Callable[["None"], "None"]
+    ) -> None:
+        """
+        Emitted when the debugger pauses or resumes."""
+
+    @typing.overload
+    def on(self, event: str, f: typing.Callable[..., None]) -> None: ...
+
+    def on(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self, event: Literal["pausedstatechanged"], f: typing.Callable[["None"], "None"]
+    ) -> None:
+        """
+        Emitted when the debugger pauses or resumes."""
+
+    @typing.overload
+    def once(self, event: str, f: typing.Callable[..., None]) -> None: ...
+
+    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def paused_details(self) -> typing.Optional[DebuggerPausedDetails]:
+        """Debugger.paused_details
+
+        Returns details about the currently paused call. Returns `null` if the debugger is not paused.
+
+        Returns
+        -------
+        Union[{location: {file: str, line: Union[int, None], column: Union[int, None]}, title: str}, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.paused_details)
+
+    def request_pause(self) -> None:
+        """Debugger.request_pause
+
+        Configures the debugger to pause before the next action is executed.
+
+        Throws if the debugger is already paused. Use `debugger.next()` or `debugger.run_to()` to step while
+        paused.
+
+        Note that `page.pause()` is equivalent to a \"debugger\" statement — it pauses execution at the call site
+        immediately. On the contrary, `debugger.request_pause()` is equivalent to \"pause on next statement\" — it
+        configures the debugger to pause before the next action is executed.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.request_pause()))
+
+    def resume(self) -> None:
+        """Debugger.resume
+
+        Resumes script execution. Throws if the debugger is not paused.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.resume()))
+
+    def next(self) -> None:
+        """Debugger.next
+
+        Resumes script execution and pauses again before the next action. Throws if the debugger is not paused.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.next()))
+
+    def run_to(self, location: DebuggerLocation) -> None:
+        """Debugger.run_to
+
+        Resumes script execution and pauses when an action originates from the given source location. Throws if the
+        debugger is not paused.
+
+        Parameters
+        ----------
+        location : {file: str, line: Union[int, None], column: Union[int, None]}
+            The source location to pause at.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.run_to(location=location))
+        )
+
+
+mapping.register(DebuggerImpl, Debugger)
+
+
+class Dialog(SyncBase):
+
+    @property
+    def type(self) -> str:
+        """Dialog.type
+
+        Returns dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.type)
+
+    @property
+    def message(self) -> str:
+        """Dialog.message
+
+        A message displayed in the dialog.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.message)
+
+    @property
+    def default_value(self) -> str:
+        """Dialog.default_value
+
+        If dialog is prompt, returns default prompt value. Otherwise, returns empty string.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.default_value)
+
+    @property
+    def page(self) -> typing.Optional["Page"]:
+        """Dialog.page
+
+        The page that initiated this dialog, if available.
+
+        Returns
+        -------
+        Union[Page, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.page)
+
+    def accept(self, prompt_text: typing.Optional[str] = None) -> None:
+        """Dialog.accept
+
+        Returns when the dialog has been accepted.
+
+        Parameters
+        ----------
+        prompt_text : Union[str, None]
+            A text to enter in prompt. Does not cause any effects if the dialog's `type` is not prompt. Optional.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.accept(promptText=prompt_text))
+        )
+
+    def dismiss(self) -> None:
+        """Dialog.dismiss
+
+        Returns when the dialog has been dismissed.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.dismiss()))
+
+
+mapping.register(DialogImpl, Dialog)
+
+
+class Download(SyncBase):
+
+    @property
+    def page(self) -> "Page":
+        """Download.page
+
+        Get the page that the download belongs to.
+
+        Returns
+        -------
+        Page
+        """
+        return mapping.from_impl(self._impl_obj.page)
+
+    @property
+    def url(self) -> str:
+        """Download.url
+
+        Returns downloaded url.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    @property
+    def suggested_filename(self) -> str:
+        """Download.suggested_filename
+
+        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.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.suggested_filename)
+
+    def delete(self) -> None:
+        """Download.delete
+
+        Deletes the downloaded file. Will wait for the download to finish if necessary.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.delete()))
+
+    def failure(self) -> typing.Optional[str]:
+        """Download.failure
+
+        Returns download error if any. Will wait for the download to finish if necessary.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.failure()))
+
+    def path(self) -> pathlib.Path:
+        """Download.path
+
+        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.suggested_filename()` to get suggested
+        file name.
+
+        Returns
+        -------
+        pathlib.Path
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.path()))
+
+    def save_as(self, path: typing.Union[str, pathlib.Path]) -> None:
+        """Download.save_as
+
+        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**
+
+        ```py
+        download.save_as(\"/path/to/save/at/\" + download.suggested_filename)
+        ```
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str]
+            Path where the download should be copied.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.save_as(path=path)))
+
+    def cancel(self) -> None:
+        """Download.cancel
+
+        Cancels a download. Will not fail if the download is already finished or canceled. Upon successful cancellations,
+        `download.failure()` would resolve to `'canceled'`.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.cancel()))
+
+
+mapping.register(DownloadImpl, Download)
+
+
+class Screencast(SyncBase):
+
+    def start(
+        self,
+        *,
+        on_frame: typing.Optional[
+            typing.Callable[[ScreencastFrame], typing.Any]
+        ] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+    ) -> "SyncContextManager":
+        """Screencast.start
+
+        Starts the screencast. When `path` is provided, it saves video recording to the specified file. When `onFrame` is
+        provided, delivers JPEG-encoded frames to the callback. Both can be used together.
+
+        **Usage**
+
+        Parameters
+        ----------
+        on_frame : Union[Callable[[{data: bytes, viewportWidth: int, viewportHeight: int}], Any], None]
+            Callback that receives JPEG-encoded frame data along with the page viewport size at the time of capture.
+        path : Union[pathlib.Path, str, None]
+            Path where the video should be saved when the screencast is stopped. When provided, video recording is started.
+        quality : Union[int, None]
+            The quality of the image, between 0-100.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.start(
+                    onFrame=self._wrap_handler(on_frame), path=path, quality=quality
+                )
+            )
+        )
+
+    def stop(self) -> None:
+        """Screencast.stop
+
+        Stops the screencast and video recording if active. If a video was being recorded, saves it to the path specified
+        in `screencast.start()`.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.stop()))
+
+    def show_actions(
+        self,
+        *,
+        duration: typing.Optional[float] = None,
+        position: typing.Optional[
+            Literal[
+                "bottom", "bottom-left", "bottom-right", "top", "top-left", "top-right"
+            ]
+        ] = None,
+        font_size: typing.Optional[int] = None,
+    ) -> "SyncContextManager":
+        """Screencast.show_actions
+
+        Enables visual annotations on interacted elements. Returns a disposable that stops showing actions when disposed.
+
+        Parameters
+        ----------
+        duration : Union[float, None]
+            How long each annotation is displayed in milliseconds. Defaults to `500`.
+        position : Union["bottom", "bottom-left", "bottom-right", "top", "top-left", "top-right", None]
+            Position of the action title overlay. Defaults to `"top-right"`.
+        font_size : Union[int, None]
+            Font size of the action title in pixels. Defaults to `24`.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.show_actions(
+                    duration=duration, position=position, fontSize=font_size
+                )
+            )
+        )
+
+    def hide_actions(self) -> None:
+        """Screencast.hide_actions
+
+        Removes action decorations.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.hide_actions()))
+
+    def show_overlay(
+        self, html: str, *, duration: typing.Optional[float] = None
+    ) -> "SyncContextManager":
+        """Screencast.show_overlay
+
+        Adds an overlay with the given HTML content. The overlay is displayed on top of the page until removed. Returns a
+        disposable that removes the overlay when disposed.
+
+        Parameters
+        ----------
+        html : str
+            HTML content for the overlay.
+        duration : Union[float, None]
+            Duration in milliseconds after which the overlay is automatically removed. Overlay stays until dismissed if not
+            provided.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(self._impl_obj.show_overlay(html=html, duration=duration))
+        )
+
+    def show_chapter(
+        self,
+        title: str,
+        *,
+        description: typing.Optional[str] = None,
+        duration: typing.Optional[float] = None,
+    ) -> None:
+        """Screencast.show_chapter
+
+        Shows a chapter overlay with a title and optional description, centered on the page with a blurred backdrop. Useful
+        for narrating video recordings. The overlay is removed after the specified duration, or 2000ms.
+
+        Parameters
+        ----------
+        title : str
+            Title text displayed prominently in the overlay.
+        description : Union[str, None]
+            Optional description text displayed below the title.
+        duration : Union[float, None]
+            Duration in milliseconds after which the overlay is automatically removed. Defaults to `2000`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.show_chapter(
+                    title=title, description=description, duration=duration
+                )
+            )
+        )
+
+    def show_overlays(self) -> None:
+        """Screencast.show_overlays
+
+        Shows overlays.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.show_overlays()))
+
+    def hide_overlays(self) -> None:
+        """Screencast.hide_overlays
+
+        Hides overlays without removing them.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.hide_overlays()))
+
+
+mapping.register(ScreencastImpl, Screencast)
+
+
+class Video(SyncBase):
+
+    def path(self) -> pathlib.Path:
+        """Video.path
+
+        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.
+
+        Returns
+        -------
+        pathlib.Path
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.path()))
+
+    def save_as(self, path: typing.Union[str, pathlib.Path]) -> None:
+        """Video.save_as
+
+        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.
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str]
+            Path where the video should be saved.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.save_as(path=path)))
+
+    def delete(self) -> None:
+        """Video.delete
+
+        Deletes the video file. Will wait for the video to finish if necessary.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.delete()))
+
+
+mapping.register(VideoImpl, Video)
+
+
+class Page(SyncContextManager):
+
+    @typing.overload
+    def on(self, event: Literal["close"], f: typing.Callable[["Page"], "None"]) -> None:
+        """
+        Emitted when the page closes."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
+    ) -> None:
+        """
+        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` event handler argument.
+
+        **Usage**
+
+        ```py
+        def print_args(msg):
+            for arg in msg.args:
+                print(arg.json_value())
+
+        page.on(\"console\", print_args)
+        page.evaluate(\"console.log('hello', 5, { foo: 'bar' })\")
+        ```"""
+
+    @typing.overload
+    def on(self, event: Literal["crash"], f: typing.Callable[["Page"], "None"]) -> None:
+        """
+        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:
+
+        ```py
+        try:
+            # crash might happen during a click.
+            page.click(\"button\")
+            # or while waiting for an event.
+            page.wait_for_event(\"popup\")
+        except Error as e:
+            pass
+            # when the page crashes, exception message contains \"crash\".
+        ```"""
+
+    @typing.overload
+    def on(
+        self, event: Literal["dialog"], f: typing.Callable[["Dialog"], "None"]
+    ) -> None:
+        """
+        Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**
+        either `dialog.accept()` or `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**
+
+        ```python
+        page.on(\"dialog\", lambda dialog: dialog.accept())
+        ```
+
+        **NOTE** When no `page.on('dialog')` or `browser_context.on('dialog')` listeners are present, all dialogs are
+        automatically dismissed."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["domcontentloaded"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        Emitted when the JavaScript
+        [`DOMContentLoaded`](https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded) event is dispatched.
+        """
+
+    @typing.overload
+    def on(
+        self, event: Literal["download"], f: typing.Callable[["Download"], "None"]
+    ) -> None:
+        """
+        Emitted when attachment download started. User can access basic file operations on downloaded content via the
+        passed `Download` instance."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["filechooser"], f: typing.Callable[["FileChooser"], "None"]
+    ) -> None:
+        """
+        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 `file_chooser.set_files()` that can be uploaded after that.
+
+        ```py
+        page.on(\"filechooser\", lambda file_chooser: file_chooser.set_files(\"/tmp/myfile.pdf\"))
+        ```"""
+
+    @typing.overload
+    def on(
+        self, event: Literal["frameattached"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is attached."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["framedetached"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is detached."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["framenavigated"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is navigated to a new url."""
+
+    @typing.overload
+    def on(self, event: Literal["load"], f: typing.Callable[["Page"], "None"]) -> None:
+        """
+        Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched.
+        """
+
+    @typing.overload
+    def on(
+        self, event: Literal["pageerror"], f: typing.Callable[["Error"], "None"]
+    ) -> None:
+        """
+        Emitted when an uncaught exception happens within the page.
+
+        ```py
+        # Log all uncaught errors to the terminal
+        page.on(\"pageerror\", lambda exc: print(f\"uncaught exception: {exc}\"))
+
+        # Navigate to a page with an exception.
+        page.goto(\"data:text/html,<script>throw new Error('test')</script>\")
+        ```"""
+
+    @typing.overload
+    def on(self, event: Literal["popup"], f: typing.Callable[["Page"], "None"]) -> None:
+        """
+        Emitted when the page opens a new tab or window. This event is emitted in addition to the
+        `browser_context.on('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 `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
+
+        ```py
+        with page.expect_event(\"popup\") as page_info:
+            page.get_by_text(\"open the popup\").click()
+        popup = page_info.value
+        print(popup.evaluate(\"location.href\"))
+        ```
+
+        **NOTE** Use `page.wait_for_load_state()` to wait until the page gets to a particular state (you should not
+        need it in most cases)."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["request"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        Emitted when a page issues a request. The [request] object is read-only. In order to intercept and mutate requests,
+        see `page.route()` or `browser_context.route()`."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["requestfailed"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        Emitted when a request fails, for example by timing out.
+
+        ```python
+        page.on(\"requestfailed\", lambda request: print(request.url + \" \" + request.failure.error_text))
+        ```
+
+        **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request
+        will complete with `page.on('request_finished')` event and not with `page.on('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."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["requestfinished"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        Emitted when a request finishes successfully after downloading the response body. For a successful response, the
+        sequence of events is `request`, `response` and `requestfinished`."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["response"], f: typing.Callable[["Response"], "None"]
+    ) -> None:
+        """
+        Emitted when [response] status and headers are received for a request. For a successful response, the sequence of
+        events is `request`, `response` and `requestfinished`."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["websocket"], f: typing.Callable[["WebSocket"], "None"]
+    ) -> None:
+        """
+        Emitted when `WebSocket` request is sent."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["worker"], f: typing.Callable[["Worker"], "None"]
+    ) -> None:
+        """
+        Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned
+        by the page."""
+
+    def on(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self, event: Literal["close"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        Emitted when the page closes."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
+    ) -> None:
+        """
+        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` event handler argument.
+
+        **Usage**
+
+        ```py
+        def print_args(msg):
+            for arg in msg.args:
+                print(arg.json_value())
+
+        page.on(\"console\", print_args)
+        page.evaluate(\"console.log('hello', 5, { foo: 'bar' })\")
+        ```"""
+
+    @typing.overload
+    def once(
+        self, event: Literal["crash"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        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:
+
+        ```py
+        try:
+            # crash might happen during a click.
+            page.click(\"button\")
+            # or while waiting for an event.
+            page.wait_for_event(\"popup\")
+        except Error as e:
+            pass
+            # when the page crashes, exception message contains \"crash\".
+        ```"""
+
+    @typing.overload
+    def once(
+        self, event: Literal["dialog"], f: typing.Callable[["Dialog"], "None"]
+    ) -> None:
+        """
+        Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**
+        either `dialog.accept()` or `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**
+
+        ```python
+        page.on(\"dialog\", lambda dialog: dialog.accept())
+        ```
+
+        **NOTE** When no `page.on('dialog')` or `browser_context.on('dialog')` listeners are present, all dialogs are
+        automatically dismissed."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["domcontentloaded"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        Emitted when the JavaScript
+        [`DOMContentLoaded`](https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded) event is dispatched.
+        """
+
+    @typing.overload
+    def once(
+        self, event: Literal["download"], f: typing.Callable[["Download"], "None"]
+    ) -> None:
+        """
+        Emitted when attachment download started. User can access basic file operations on downloaded content via the
+        passed `Download` instance."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["filechooser"], f: typing.Callable[["FileChooser"], "None"]
+    ) -> None:
+        """
+        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 `file_chooser.set_files()` that can be uploaded after that.
+
+        ```py
+        page.on(\"filechooser\", lambda file_chooser: file_chooser.set_files(\"/tmp/myfile.pdf\"))
+        ```"""
+
+    @typing.overload
+    def once(
+        self, event: Literal["frameattached"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is attached."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["framedetached"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is detached."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["framenavigated"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is navigated to a new url."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["load"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched.
+        """
+
+    @typing.overload
+    def once(
+        self, event: Literal["pageerror"], f: typing.Callable[["Error"], "None"]
+    ) -> None:
+        """
+        Emitted when an uncaught exception happens within the page.
+
+        ```py
+        # Log all uncaught errors to the terminal
+        page.on(\"pageerror\", lambda exc: print(f\"uncaught exception: {exc}\"))
+
+        # Navigate to a page with an exception.
+        page.goto(\"data:text/html,<script>throw new Error('test')</script>\")
+        ```"""
+
+    @typing.overload
+    def once(
+        self, event: Literal["popup"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        Emitted when the page opens a new tab or window. This event is emitted in addition to the
+        `browser_context.on('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 `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
+
+        ```py
+        with page.expect_event(\"popup\") as page_info:
+            page.get_by_text(\"open the popup\").click()
+        popup = page_info.value
+        print(popup.evaluate(\"location.href\"))
+        ```
+
+        **NOTE** Use `page.wait_for_load_state()` to wait until the page gets to a particular state (you should not
+        need it in most cases)."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["request"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        Emitted when a page issues a request. The [request] object is read-only. In order to intercept and mutate requests,
+        see `page.route()` or `browser_context.route()`."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["requestfailed"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        Emitted when a request fails, for example by timing out.
+
+        ```python
+        page.on(\"requestfailed\", lambda request: print(request.url + \" \" + request.failure.error_text))
+        ```
+
+        **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request
+        will complete with `page.on('request_finished')` event and not with `page.on('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."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["requestfinished"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        Emitted when a request finishes successfully after downloading the response body. For a successful response, the
+        sequence of events is `request`, `response` and `requestfinished`."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["response"], f: typing.Callable[["Response"], "None"]
+    ) -> None:
+        """
+        Emitted when [response] status and headers are received for a request. For a successful response, the sequence of
+        events is `request`, `response` and `requestfinished`."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["websocket"], f: typing.Callable[["WebSocket"], "None"]
+    ) -> None:
+        """
+        Emitted when `WebSocket` request is sent."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["worker"], f: typing.Callable[["Worker"], "None"]
+    ) -> None:
+        """
+        Emitted when a dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is spawned
+        by the page."""
+
+    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def keyboard(self) -> "Keyboard":
+        """Page.keyboard
+
+        Returns
+        -------
+        Keyboard
+        """
+        return mapping.from_impl(self._impl_obj.keyboard)
+
+    @property
+    def mouse(self) -> "Mouse":
+        """Page.mouse
+
+        Returns
+        -------
+        Mouse
+        """
+        return mapping.from_impl(self._impl_obj.mouse)
+
+    @property
+    def touchscreen(self) -> "Touchscreen":
+        """Page.touchscreen
+
+        Returns
+        -------
+        Touchscreen
+        """
+        return mapping.from_impl(self._impl_obj.touchscreen)
+
+    @property
+    def context(self) -> "BrowserContext":
+        """Page.context
+
+        Get the browser context that the page belongs to.
+
+        Returns
+        -------
+        BrowserContext
+        """
+        return mapping.from_impl(self._impl_obj.context)
+
+    @property
+    def clock(self) -> "Clock":
+        """Page.clock
+
+        Playwright has ability to mock clock and passage of time.
+
+        Returns
+        -------
+        Clock
+        """
+        return mapping.from_impl(self._impl_obj.clock)
+
+    @property
+    def main_frame(self) -> "Frame":
+        """Page.main_frame
+
+        The page's main frame. Page is guaranteed to have a main frame which persists during navigations.
+
+        Returns
+        -------
+        Frame
+        """
+        return mapping.from_impl(self._impl_obj.main_frame)
+
+    @property
+    def frames(self) -> typing.List["Frame"]:
+        """Page.frames
+
+        An array of all frames attached to the page.
+
+        Returns
+        -------
+        List[Frame]
+        """
+        return mapping.from_impl_list(self._impl_obj.frames)
+
+    @property
+    def url(self) -> str:
+        """Page.url
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
+
+    @property
+    def viewport_size(self) -> typing.Optional[ViewportSize]:
+        """Page.viewport_size
+
+        Returns
+        -------
+        Union[{width: int, height: int}, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.viewport_size)
+
+    @property
+    def workers(self) -> typing.List["Worker"]:
+        """Page.workers
+
+        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
+
+        Returns
+        -------
+        List[Worker]
+        """
+        return mapping.from_impl_list(self._impl_obj.workers)
+
+    @property
+    def request(self) -> "APIRequestContext":
+        """Page.request
+
+        API testing helper associated with this page. This method returns the same instance as
+        `browser_context.request` on the page's context. See `browser_context.request` for more
+        details.
+
+        Returns
+        -------
+        APIRequestContext
+        """
+        return mapping.from_impl(self._impl_obj.request)
+
+    @property
+    def video(self) -> typing.Optional["Video"]:
+        """Page.video
+
+        Video object associated with this page. Can be used to access the video file when using the `recordVideo` context
+        option.
+
+        Returns
+        -------
+        Union[Video, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.video)
+
+    @property
+    def screencast(self) -> "Screencast":
+        """Page.screencast
+
+        `Screencast` object associated with this page.
+
+        **Usage**
+
+        Returns
+        -------
+        Screencast
+        """
+        return mapping.from_impl(self._impl_obj.screencast)
+
+    def opener(self) -> typing.Optional["Page"]:
+        """Page.opener
+
+        Returns the opener for popup pages and `null` for others. If the opener has been closed already the returns `null`.
+
+        Returns
+        -------
+        Union[Page, None]
+        """
+
+        return mapping.from_impl_nullable(self._sync(self._impl_obj.opener()))
+
+    def frame(
+        self,
+        name: typing.Optional[str] = None,
+        *,
+        url: typing.Optional[
+            typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]]
+        ] = None,
+    ) -> typing.Optional["Frame"]:
+        """Page.frame
+
+        Returns frame matching the specified criteria. Either `name` or `url` must be specified.
+
+        **Usage**
+
+        ```py
+        frame = page.frame(url=r\".*domain.*\")
+        ```
+
+        Parameters
+        ----------
+        name : Union[str, None]
+            Frame name specified in the `iframe`'s `name` attribute. Optional.
+        url : Union[Callable[[str], bool], Pattern[str], str, None]
+            A glob pattern, regex pattern or predicate receiving frame's `url` as a [URL] object. Optional.
+
+        Returns
+        -------
+        Union[Frame, None]
+        """
+
+        return mapping.from_impl_nullable(
+            self._impl_obj.frame(name=name, url=self._wrap_handler(url))
+        )
+
+    def set_default_navigation_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """Page.set_default_navigation_timeout
+
+        This setting will change the default maximum navigation time for the following methods and related shortcuts:
+        - `page.go_back()`
+        - `page.go_forward()`
+        - `page.goto()`
+        - `page.reload()`
+        - `page.set_content()`
+        - `page.expect_navigation()`
+        - `page.wait_for_url()`
+
+        **NOTE** `page.set_default_navigation_timeout()` takes priority over `page.set_default_timeout()`,
+        `browser_context.set_default_timeout()` and `browser_context.set_default_navigation_timeout()`.
+
+        Parameters
+        ----------
+        timeout : float
+            Maximum navigation time in milliseconds
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_default_navigation_timeout(
+                timeout=to_milliseconds(timeout)
+            )
+        )
+
+    def set_default_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """Page.set_default_timeout
+
+        This setting will change the default maximum time for all the methods accepting `timeout` option.
+
+        **NOTE** `page.set_default_navigation_timeout()` takes priority over `page.set_default_timeout()`.
+
+        Parameters
+        ----------
+        timeout : float
+            Maximum time in milliseconds. Pass `0` to disable timeout.
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_default_timeout(timeout=to_milliseconds(timeout))
+        )
+
+    def query_selector(
+        self, selector: str, *, strict: typing.Optional[bool] = None
+    ) -> typing.Optional["ElementHandle"]:
+        """Page.query_selector
+
+        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.wait_for()`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        strict : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Union[ElementHandle, None]
+        """
+
+        return mapping.from_impl_nullable(
+            self._sync(self._impl_obj.query_selector(selector=selector, strict=strict))
+        )
+
+    def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
+        """Page.query_selector_all
+
+        The method finds all elements matching the specified selector within the page. If no elements match the selector,
+        the return value resolves to `[]`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+
+        Returns
+        -------
+        List[ElementHandle]
+        """
+
+        return mapping.from_impl_list(
+            self._sync(self._impl_obj.query_selector_all(selector=selector))
+        )
+
+    def wait_for_selector(
+        self,
+        selector: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        state: typing.Optional[
+            Literal["attached", "detached", "hidden", "visible"]
+        ] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> typing.Optional["ElementHandle"]:
+        """Page.wait_for_selector
+
+        Returns when element specified by selector satisfies `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`
+        objects and web-first assertions makes the code wait-for-selector-free.
+
+        Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If
+        at the moment of calling the method `selector` already satisfies the condition, the method will return immediately.
+        If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
+
+        **Usage**
+
+        This method works across navigations:
+
+        ```py
+        from playwright.sync_api import sync_playwright, Playwright
+
+        def run(playwright: Playwright):
+            chromium = playwright.chromium
+            browser = chromium.launch()
+            page = browser.new_page()
+            for current_url in [\"https://google.com\", \"https://bbc.com\"]:
+                page.goto(current_url, wait_until=\"domcontentloaded\")
+                element = page.wait_for_selector(\"img\")
+                print(\"Loaded image: \" + str(element.get_attribute(\"src\")))
+            browser.close()
+
+        with sync_playwright() as playwright:
+            run(playwright)
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        state : Union["attached", "detached", "hidden", "visible", None]
+            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.
+        strict : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Union[ElementHandle, None]
+        """
+
+        return mapping.from_impl_nullable(
+            self._sync(
+                self._impl_obj.wait_for_selector(
+                    selector=selector,
+                    timeout=to_milliseconds(timeout),
+                    state=state,
+                    strict=strict,
+                )
+            )
+        )
+
+    def is_checked(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_checked
+
+        Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.is_checked(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def is_disabled(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_disabled
+
+        Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability#enabled).
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.is_disabled(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def is_editable(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_editable
+
+        Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.is_editable(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def is_enabled(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_enabled
+
+        Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.is_enabled(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def is_hidden(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_hidden
+
+        Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability#visible).  `selector` that
+        does not match any elements is considered hidden.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Deprecated: This option is ignored. `page.is_hidden()` does not wait for the↵element to become hidden and returns immediately.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.is_hidden(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def is_visible(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Page.is_visible
+
+        Returns whether the element is [visible](https://playwright.dev/python/docs/actionability#visible). `selector` that does not match any elements
+        is considered not visible.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Deprecated: This option is ignored. `page.is_visible()` does not wait↵for the element to become visible and returns immediately.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.is_visible(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def dispatch_event(
+        self,
+        selector: str,
+        type: str,
+        event_init: typing.Optional[typing.Dict] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.dispatch_event
+
+        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**
+
+        ```py
+        page.dispatch_event(\"button#submit\", \"click\")
+        ```
+
+        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit`
+        properties and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
+
+        Since `eventInit` 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:
+
+        ```py
+        # note you can only create data_transfer in chromium and firefox
+        data_transfer = page.evaluate_handle(\"new DataTransfer()\")
+        page.dispatch_event(\"#source\", \"dragstart\", { \"dataTransfer\": data_transfer })
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        type : str
+            DOM event type: `"click"`, `"dragstart"`, etc.
+        event_init : Union[Dict, None]
+            Optional event-specific initialization properties.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        strict : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.dispatch_event(
+                    selector=selector,
+                    type=type,
+                    eventInit=mapping.to_impl(event_init),
+                    timeout=to_milliseconds(timeout),
+                    strict=strict,
+                )
+            )
+        )
+
+    def evaluate(
+        self, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> typing.Any:
+        """Page.evaluate
+
+        Returns the value of the `expression` invocation.
+
+        If the function passed to the `page.evaluate()` returns a [Promise], then `page.evaluate()` would
+        wait for the promise to resolve and return its value.
+
+        If the function passed to the `page.evaluate()` returns a non-[Serializable] value, then
+        `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 `expression`:
+
+        ```py
+        result = page.evaluate(\"([x, y]) => Promise.resolve(x * y)\", [7, 8])
+        print(result) # prints \"56\"
+        ```
+
+        A string can also be passed in instead of a function:
+
+        ```py
+        print(page.evaluate(\"1 + 2\")) # prints \"3\"
+        x = 10
+        print(page.evaluate(f\"1 + {x}\")) # prints \"11\"
+        ```
+
+        `ElementHandle` instances can be passed as an argument to the `page.evaluate()`:
+
+        ```py
+        body_handle = page.evaluate(\"document.body\")
+        html = page.evaluate(\"([body, suffix]) => body.innerHTML + suffix\", [body_handle, \"hello\"])
+        body_handle.dispose()
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.evaluate(expression=expression, arg=mapping.to_impl(arg))
+            )
+        )
+
+    def evaluate_handle(
+        self, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> "JSHandle":
+        """Page.evaluate_handle
+
+        Returns the value of the `expression` invocation as a `JSHandle`.
+
+        The only difference between `page.evaluate()` and `page.evaluate_handle()` is that
+        `page.evaluate_handle()` returns `JSHandle`.
+
+        If the function passed to the `page.evaluate_handle()` returns a [Promise], then
+        `page.evaluate_handle()` would wait for the promise to resolve and return its value.
+
+        **Usage**
+
+        ```py
+        a_window_handle = page.evaluate_handle(\"Promise.resolve(window)\")
+        a_window_handle # handle for the window object.
+        ```
+
+        A string can also be passed in instead of a function:
+
+        ```py
+        a_handle = page.evaluate_handle(\"document\") # handle for the \"document\"
+        ```
+
+        `JSHandle` instances can be passed as an argument to the `page.evaluate_handle()`:
+
+        ```py
+        a_handle = page.evaluate_handle(\"document.body\")
+        result_handle = page.evaluate_handle(\"body => body.innerHTML\", a_handle)
+        print(result_handle.json_value())
+        result_handle.dispose()
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        JSHandle
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.evaluate_handle(
+                    expression=expression, arg=mapping.to_impl(arg)
+                )
+            )
+        )
+
+    def eval_on_selector(
+        self,
+        selector: str,
+        expression: str,
+        arg: typing.Optional[typing.Any] = None,
+        *,
+        strict: typing.Optional[bool] = None,
+    ) -> typing.Any:
+        """Page.eval_on_selector
+
+        The method finds an element matching the specified selector within the page and passes it as a first argument to
+        `expression`. If no elements match the selector, the method throws an error. Returns the value of `expression`.
+
+        If `expression` returns a [Promise], then `page.eval_on_selector()` would wait for the promise to resolve and
+        return its value.
+
+        **Usage**
+
+        ```py
+        search_value = page.eval_on_selector(\"#search\", \"el => el.value\")
+        preload_href = page.eval_on_selector(\"link[rel=preload]\", \"el => el.href\")
+        html = page.eval_on_selector(\".main-container\", \"(e, suffix) => e.outer_html + suffix\", \"hello\")
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        strict : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.eval_on_selector(
+                    selector=selector,
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    strict=strict,
+                )
+            )
+        )
+
+    def eval_on_selector_all(
+        self, selector: str, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> typing.Any:
+        """Page.eval_on_selector_all
+
+        The method finds all elements matching the specified selector within the page and passes an array of matched
+        elements as a first argument to `expression`. Returns the result of `expression` invocation.
+
+        If `expression` returns a [Promise], then `page.eval_on_selector_all()` would wait for the promise to resolve
+        and return its value.
+
+        **Usage**
+
+        ```py
+        div_counts = page.eval_on_selector_all(\"div\", \"(divs, min) => divs.length >= min\", 10)
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to query for.
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.eval_on_selector_all(
+                    selector=selector, expression=expression, arg=mapping.to_impl(arg)
+                )
+            )
+        )
+
+    def add_script_tag(
+        self,
+        *,
+        url: typing.Optional[str] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
+        type: typing.Optional[str] = None,
+    ) -> "ElementHandle":
+        """Page.add_script_tag
+
+        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.
+
+        Parameters
+        ----------
+        url : Union[str, None]
+            URL of a script to be added.
+        path : Union[pathlib.Path, str, None]
+            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.
+        content : Union[str, None]
+            Raw JavaScript content to be injected into frame.
+        type : Union[str, None]
+            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.
+
+        Returns
+        -------
+        ElementHandle
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.add_script_tag(
+                    url=url, path=path, content=content, type=type
+                )
+            )
+        )
+
+    def add_style_tag(
+        self,
+        *,
+        url: typing.Optional[str] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        content: typing.Optional[str] = None,
+    ) -> "ElementHandle":
+        """Page.add_style_tag
+
+        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.
+
+        Parameters
+        ----------
+        url : Union[str, None]
+            URL of the `<link>` tag.
+        path : Union[pathlib.Path, str, None]
+            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.
+        content : Union[str, None]
+            Raw CSS content to be injected into frame.
+
+        Returns
+        -------
+        ElementHandle
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.add_style_tag(url=url, path=path, content=content)
+            )
+        )
+
+    def expose_function(
+        self, name: str, callback: typing.Callable
+    ) -> "SyncContextManager":
+        """Page.expose_function
+
+        The method adds a function called `name` on the `window` object of every frame in the page. When called, the
+        function executes `callback` and returns a [Promise] which resolves to the return value of `callback`.
+
+        If the `callback` returns a [Promise], it will be awaited.
+
+        See `browser_context.expose_function()` for context-wide exposed function.
+
+        **NOTE** Functions installed via `page.expose_function()` survive navigations.
+
+        **Usage**
+
+        An example of adding a `sha256` function to the page:
+
+        ```py
+        import hashlib
+        from playwright.sync_api import sync_playwright, Playwright
+
+        def sha256(text):
+            m = hashlib.sha256()
+            m.update(bytes(text, \"utf8\"))
+            return m.hexdigest()
+
+        def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = webkit.launch(headless=False)
+            page = browser.new_page()
+            page.expose_function(\"sha256\", sha256)
+            page.set_content(\"\"\"
+                <script>
+                  async function onClick() {
+                    document.querySelector('div').textContent = await window.sha256('PLAYWRIGHT');
+                  }
+                </script>
+                <button onclick=\"onClick()\">Click me</button>
+                <div></div>
+            \"\"\")
+            page.click(\"button\")
+
+        with sync_playwright() as playwright:
+            run(playwright)
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Name of the function on the window object
+        callback : Callable
+            Callback function which will be called in Playwright's context.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.expose_function(
+                    name=name, callback=self._wrap_handler(callback)
+                )
+            )
+        )
+
+    def expose_binding(
+        self, name: str, callback: typing.Callable
+    ) -> "SyncContextManager":
+        """Page.expose_binding
+
+        The method adds a function called `name` on the `window` object of every frame in this page. When called, the
+        function executes `callback` and returns a [Promise] which resolves to the return value of `callback`. If the
+        `callback` returns a [Promise], it will be awaited.
+
+        The first argument of the `callback` function contains information about the caller: `{ browserContext:
+        BrowserContext, page: Page, frame: Frame }`.
+
+        See `browser_context.expose_binding()` for the context-wide version.
+
+        **NOTE** Functions installed via `page.expose_binding()` survive navigations.
+
+        **Usage**
+
+        An example of exposing page URL to all frames in a page:
+
+        ```py
+        from playwright.sync_api import sync_playwright, Playwright
+
+        def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = webkit.launch(headless=False)
+            context = browser.new_context()
+            page = context.new_page()
+            page.expose_binding(\"pageURL\", lambda source: source[\"page\"].url)
+            page.set_content(\"\"\"
+            <script>
+              async function onClick() {
+                document.querySelector('div').textContent = await window.pageURL();
+              }
+            </script>
+            <button onclick=\"onClick()\">Click me</button>
+            <div></div>
+            \"\"\")
+            page.click(\"button\")
+
+        with sync_playwright() as playwright:
+            run(playwright)
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Name of the function on the window object.
+        callback : Callable
+            Callback function that will be called in the Playwright's context.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.expose_binding(
+                    name=name, callback=self._wrap_handler(callback)
+                )
+            )
+        )
+
+    def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> None:
+        """Page.set_extra_http_headers
+
+        The extra HTTP headers will be sent with every request the page initiates.
+
+        **NOTE** `page.set_extra_http_headers()` does not guarantee the order of headers in the outgoing requests.
+
+        Parameters
+        ----------
+        headers : Dict[str, str]
+            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_extra_http_headers(headers=mapping.to_impl(headers))
+            )
+        )
+
+    def content(self) -> str:
+        """Page.content
+
+        Gets the full HTML contents of the page, including the doctype.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.content()))
+
+    def set_content(
+        self,
+        html: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> None:
+        """Page.set_content
+
+        This method internally calls [document.write()](https://developer.mozilla.org/en-US/docs/Web/API/Document/write),
+        inheriting all its specific characteristics and behaviors.
+
+        Parameters
+        ----------
+        html : str
+            HTML markup to assign to the page.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_content(
+                    html=html, timeout=to_milliseconds(timeout), waitUntil=wait_until
+                )
+            )
+        )
+
+    def goto(
+        self,
+        url: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        referer: typing.Optional[str] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.goto
+
+        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` 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()`.
+
+        **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).
+
+        Parameters
+        ----------
+        url : str
+            URL to navigate page to. The url should include scheme, e.g. `https://`. When a `baseURL` 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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+        referer : Union[str, None]
+            Referer header value. If provided it will take preference over the referer header value set by
+            `page.set_extra_http_headers()`.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+
+        return mapping.from_impl_nullable(
+            self._sync(
+                self._impl_obj.goto(
+                    url=url,
+                    timeout=to_milliseconds(timeout),
+                    waitUntil=wait_until,
+                    referer=referer,
+                )
+            )
+        )
+
+    def reload(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.reload
+
+        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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+
+        return mapping.from_impl_nullable(
+            self._sync(
+                self._impl_obj.reload(
+                    timeout=to_milliseconds(timeout), waitUntil=wait_until
+                )
+            )
+        )
+
+    def wait_for_load_state(
+        self,
+        state: typing.Optional[
+            Literal["domcontentloaded", "load", "networkidle"]
+        ] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Page.wait_for_load_state
+
+        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/python/docs/actionability).
+
+        **Usage**
+
+        ```py
+        page.get_by_role(\"button\").click() # click triggers navigation.
+        page.wait_for_load_state() # the promise resolves after \"load\" event.
+        ```
+
+        ```py
+        with page.expect_popup() as page_info:
+            page.get_by_role(\"button\").click() # click triggers a popup.
+        popup = page_info.value
+        # Wait for the \"DOMContentLoaded\" event.
+        popup.wait_for_load_state(\"domcontentloaded\")
+        print(popup.title()) # popup is ready to use.
+        ```
+
+        Parameters
+        ----------
+        state : Union["domcontentloaded", "load", "networkidle", None]
+            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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_load_state(
+                    state=state, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def wait_for_url(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        *,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Page.wait_for_url
+
+        Waits for the main frame to navigate to the given URL.
+
+        **Usage**
+
+        ```py
+        page.click(\"a.delayed-navigation\") # clicking the link will indirectly cause a navigation
+        page.wait_for_url(\"**/target.html\")
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            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.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_url(
+                    url=self._wrap_handler(url),
+                    waitUntil=wait_until,
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "ConsoleMessage": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["crash"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Dialog": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["domcontentloaded"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Download": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["filechooser"],
+        predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "FileChooser": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["load"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["pageerror"],
+        predicate: typing.Optional[typing.Callable[["Error"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Error": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["popup"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Response": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["websocket"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebSocket": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["worker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Worker": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
+
+    def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Any:
+        """Page.wait_for_event
+
+        **NOTE** In most cases, you should use `page.expect_event()`.
+
+        Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function
+        and waits for `predicate(event)` to return a truthy value. Will throw an error if the page is closed before the
+        `event` is fired.
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_event(
+                    event=event,
+                    predicate=self._wrap_handler(predicate),
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
+
+    def go_back(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.go_back
+
+        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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+
+        return mapping.from_impl_nullable(
+            self._sync(
+                self._impl_obj.go_back(
+                    timeout=to_milliseconds(timeout), waitUntil=wait_until
+                )
+            )
+        )
+
+    def go_forward(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+    ) -> typing.Optional["Response"]:
+        """Page.go_forward
+
+        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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+
+        Returns
+        -------
+        Union[Response, None]
+        """
+
+        return mapping.from_impl_nullable(
+            self._sync(
+                self._impl_obj.go_forward(
+                    timeout=to_milliseconds(timeout), waitUntil=wait_until
+                )
+            )
+        )
+
+    def request_gc(self) -> None:
+        """Page.request_gc
+
+        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).
+
+        ```py
+        # 1. In your page, save a WeakRef for the \"suspect\".
+        page.evaluate(\"globalThis.suspectWeakRef = new WeakRef(suspect)\")
+        # 2. Request garbage collection.
+        page.request_gc()
+        # 3. Check that weak ref does not deref to the original object.
+        assert page.evaluate(\"!globalThis.suspectWeakRef.deref()\")
+        ```
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.request_gc()))
+
+    def emulate_media(
+        self,
+        *,
+        media: typing.Optional[Literal["null", "print", "screen"]] = None,
+        color_scheme: typing.Optional[
+            Literal["dark", "light", "no-preference", "null"]
+        ] = None,
+        reduced_motion: typing.Optional[
+            Literal["no-preference", "null", "reduce"]
+        ] = None,
+        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
+    ) -> None:
+        """Page.emulate_media
+
+        This method changes the `CSS media type` through the `media` argument, and/or the `'prefers-colors-scheme'` media
+        feature, using the `colorScheme` argument.
+
+        **Usage**
+
+        ```py
+        page.evaluate(\"matchMedia('screen').matches\")
+        # → True
+        page.evaluate(\"matchMedia('print').matches\")
+        # → False
+
+        page.emulate_media(media=\"print\")
+        page.evaluate(\"matchMedia('screen').matches\")
+        # → False
+        page.evaluate(\"matchMedia('print').matches\")
+        # → True
+
+        page.emulate_media()
+        page.evaluate(\"matchMedia('screen').matches\")
+        # → True
+        page.evaluate(\"matchMedia('print').matches\")
+        # → False
+        ```
+
+        ```py
+        page.emulate_media(color_scheme=\"dark\")
+        page.evaluate(\"matchMedia('(prefers-color-scheme: dark)').matches\")
+        # → True
+        page.evaluate(\"matchMedia('(prefers-color-scheme: light)').matches\")
+        # → False
+        ```
+
+        Parameters
+        ----------
+        media : Union["null", "print", "screen", None]
+            Changes the CSS media type of the page. The only allowed values are `'Screen'`, `'Print'` and `'Null'`. Passing
+            `'Null'` disables CSS media emulation.
+        color_scheme : Union["dark", "light", "no-preference", "null", None]
+            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.
+        reduced_motion : Union["no-preference", "null", "reduce", None]
+            Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. Passing
+            `null` disables reduced motion emulation.
+        forced_colors : Union["active", "none", "null", None]
+        contrast : Union["more", "no-preference", "null", None]
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.emulate_media(
+                    media=media,
+                    colorScheme=color_scheme,
+                    reducedMotion=reduced_motion,
+                    forcedColors=forced_colors,
+                    contrast=contrast,
+                )
+            )
+        )
+
+    def set_viewport_size(self, viewport_size: ViewportSize) -> None:
+        """Page.set_viewport_size
+
+        In the case of multiple pages in a single browser, each page can have its own viewport size. However,
+        `browser.new_context()` allows to set viewport size (and more) for all pages in the context at once.
+
+        `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.set_viewport_size()` will also reset
+        `screen` size, use `browser.new_context()` with `screen` and `viewport` parameters if you need better
+        control of these properties.
+
+        **Usage**
+
+        ```py
+        page = browser.new_page()
+        page.set_viewport_size({\"width\": 640, \"height\": 480})
+        page.goto(\"https://example.com\")
+        ```
+
+        Parameters
+        ----------
+        viewport_size : {width: int, height: int}
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.set_viewport_size(viewportSize=viewport_size))
+        )
+
+    def bring_to_front(self) -> None:
+        """Page.bring_to_front
+
+        Brings page to front (activates tab).
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.bring_to_front()))
+
+    def hide_highlight(self) -> None:
+        """Page.hide_highlight
+
+        Hide all locator highlight overlays previously added by `locator.highlight()` on this page.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.hide_highlight()))
+
+    def add_init_script(
+        self,
+        script: typing.Optional[str] = None,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+    ) -> "SyncContextManager":
+        """Page.add_init_script
+
+        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:
+
+        ```py
+        # in your playwright script, assuming the preload.js file is in same directory
+        page.add_init_script(path=\"./preload.js\")
+        ```
+
+        **NOTE** The order of evaluation of multiple scripts installed via `browser_context.add_init_script()` and
+        `page.add_init_script()` is not defined.
+
+        Parameters
+        ----------
+        script : Union[str, None]
+            Script to be evaluated in all pages in the browser context. Optional.
+        path : Union[pathlib.Path, str, None]
+            Path to the JavaScript file. If `path` is a relative path, then it is resolved relative to the current working
+            directory. Optional.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(self._impl_obj.add_init_script(script=script, path=path))
+        )
+
+    def route(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Union[
+            typing.Callable[["Route"], typing.Any],
+            typing.Callable[["Route", "Request"], typing.Any],
+        ],
+        *,
+        times: typing.Optional[int] = None,
+    ) -> "SyncContextManager":
+        """Page.route
+
+        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()` 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` to `'block'`.
+
+        **NOTE** `page.route()` will not intercept the first request of a popup page. Use
+        `browser_context.route()` instead.
+
+        **Usage**
+
+        An example of a naive handler that aborts all image requests:
+
+        ```py
+        page = browser.new_page()
+        page.route(\"**/*.{png,jpg,jpeg}\", lambda route: route.abort())
+        page.goto(\"https://example.com\")
+        browser.close()
+        ```
+
+        or the same snippet using a regex pattern instead:
+
+        ```py
+        page = browser.new_page()
+        page.route(re.compile(r\"(\\.png$)|(\\.jpg$)\"), lambda route: route.abort())
+        page.goto(\"https://example.com\")
+        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:
+
+        ```py
+        def handle_route(route: Route):
+          if (\"my-string\" in route.request.post_data):
+            route.fulfill(body=\"mocked-data\")
+          else:
+            route.continue_()
+        page.route(\"/api/**\", handle_route)
+        ```
+
+        If a request matches multiple registered routes, the most recently registered route takes precedence.
+
+        Page routes take precedence over browser context routes (set up with `browser_context.route()`) when request
+        matches both handlers.
+
+        To remove a route with its handler you can use `page.unroute()`.
+
+        **NOTE** Enabling routing disables http cache.
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            A glob pattern, regex pattern, or predicate that receives a [URL] to match during routing. If `baseURL` is set in
+            the context options and the provided URL is a string that does not start with `*`, it is resolved using the
+            [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.
+        handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
+            handler function to route the request.
+        times : Union[int, None]
+            How often a route should be used. By default it will be used every time.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.route(
+                    url=self._wrap_handler(url),
+                    handler=self._wrap_handler(handler),
+                    times=times,
+                )
+            )
+        )
+
+    def unroute(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Optional[
+            typing.Union[
+                typing.Callable[["Route"], typing.Any],
+                typing.Callable[["Route", "Request"], typing.Any],
+            ]
+        ] = None,
+    ) -> None:
+        """Page.unroute
+
+        Removes a route created with `page.route()`. When `handler` is not specified, removes all routes for the
+        `url`.
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            A glob pattern, regex pattern, or predicate receiving [URL] to match while routing.
+        handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
+            Optional handler function to route the request.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.unroute(
+                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                )
+            )
+        )
+
+    def route_web_socket(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Callable[["WebSocketRoute"], typing.Any],
+    ) -> None:
+        """Page.route_web_socket
+
+        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` for more details and
+        examples.
+
+        ```py
+        def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+          if message == \"request\":
+            ws.send(\"response\")
+
+        def handler(ws: WebSocketRoute):
+          ws.on_message(lambda message: message_handler(ws, message))
+
+        page.route_web_socket(\"/ws\", handler)
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            Only WebSockets with the url matching this pattern will be routed. A string pattern can be relative to the
+            `baseURL` context option.
+        handler : Callable[[WebSocketRoute], Any]
+            Handler function to route the WebSocket.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.route_web_socket(
+                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                )
+            )
+        )
+
+    def unroute_all(
+        self,
+        *,
+        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None,
+    ) -> None:
+        """Page.unroute_all
+
+        Removes all routes created with `page.route()` and `page.route_from_har()`.
+
+        Parameters
+        ----------
+        behavior : Union["default", "ignoreErrors", "wait", None]
+            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
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.unroute_all(behavior=behavior))
+        )
+
+    def route_from_har(
+        self,
+        har: typing.Union[pathlib.Path, str],
+        *,
+        url: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        not_found: typing.Optional[Literal["abort", "fallback"]] = None,
+        update: typing.Optional[bool] = None,
+        update_content: typing.Optional[Literal["attach", "embed"]] = None,
+        update_mode: typing.Optional[Literal["full", "minimal"]] = None,
+    ) -> None:
+        """Page.route_from_har
+
+        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/python/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` to `'block'`.
+
+        Parameters
+        ----------
+        har : Union[pathlib.Path, str]
+            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.
+        url : Union[Pattern[str], str, None]
+            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.
+        not_found : Union["abort", "fallback", None]
+            - 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.
+        update : Union[bool, None]
+            If specified, updates the given HAR with the actual network information instead of serving from file. The file is
+            written to disk when `browser_context.close()` is called.
+        update_content : Union["attach", "embed", None]
+            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.
+        update_mode : Union["full", "minimal", None]
+            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`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.route_from_har(
+                    har=har,
+                    url=url,
+                    notFound=not_found,
+                    update=update,
+                    updateContent=update_content,
+                    updateMode=update_mode,
+                )
+            )
+        )
+
+    def screenshot(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        type: typing.Optional[Literal["jpeg", "png"]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+        omit_background: typing.Optional[bool] = None,
+        full_page: typing.Optional[bool] = None,
+        clip: typing.Optional[FloatRect] = None,
+        animations: typing.Optional[Literal["allow", "disabled"]] = None,
+        caret: typing.Optional[Literal["hide", "initial"]] = None,
+        scale: typing.Optional[Literal["css", "device"]] = None,
+        mask: typing.Optional[typing.Sequence["Locator"]] = None,
+        mask_color: typing.Optional[str] = None,
+        style: typing.Optional[str] = None,
+    ) -> bytes:
+        """Page.screenshot
+
+        Returns the buffer with the captured screenshot.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        type : Union["jpeg", "png", None]
+            Specify screenshot type, defaults to `png`.
+        path : Union[pathlib.Path, str, None]
+            The file path to save the image to. The screenshot type will be inferred from file extension. If `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.
+        quality : Union[int, None]
+            The quality of the image, between 0-100. Not applicable to `png` images.
+        omit_background : Union[bool, None]
+            Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.
+            Defaults to `false`.
+        full_page : Union[bool, None]
+            When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Defaults to
+            `false`.
+        clip : Union[{x: float, y: float, width: float, height: float}, None]
+            An object which specifies clipping of the resulting image.
+        animations : Union["allow", "disabled", None]
+            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.
+        caret : Union["hide", "initial", None]
+            When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be
+            changed.  Defaults to `"hide"`.
+        scale : Union["css", "device", None]
+            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"`.
+        mask : Union[Sequence[Locator], None]
+            Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
+        mask_color : Union[str, None]
+            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`.
+        style : Union[str, None]
+            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.
+
+        Returns
+        -------
+        bytes
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.screenshot(
+                    timeout=to_milliseconds(timeout),
+                    type=type,
+                    path=path,
+                    quality=quality,
+                    omitBackground=omit_background,
+                    fullPage=full_page,
+                    clip=clip,
+                    animations=animations,
+                    caret=caret,
+                    scale=scale,
+                    mask=mapping.to_impl(mask),
+                    maskColor=mask_color,
+                    style=style,
+                )
+            )
+        )
+
+    def title(self) -> str:
+        """Page.title
+
+        Returns the page's title.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.title()))
+
+    def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        depth: typing.Optional[int] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = None,
+        boxes: typing.Optional[bool] = None,
+    ) -> str:
+        """Page.aria_snapshot
+
+        Captures the aria snapshot of the page. Read more about [aria snapshots](https://playwright.dev/python/docs/aria-snapshots).
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
+        mode : Union["ai", "default", None]
+            When set to `"ai"`, returns a snapshot optimized for AI consumption: including element references like `[ref=e2]`
+            and snapshots of `<iframe>`s. Defaults to `"default"`.
+        boxes : Union[bool, None]
+            When `true`, appends each element's bounding box as `[box=x,y,width,height]` to the snapshot. Coordinates are
+            relative to the viewport, in CSS pixels, as returned by
+            [`Element.getBoundingClientRect()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
+            Defaults to `false`.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.aria_snapshot(
+                    timeout=to_milliseconds(timeout),
+                    depth=depth,
+                    mode=mode,
+                    boxes=boxes,
+                )
+            )
+        )
+
+    def close(
+        self,
+        *,
+        run_before_unload: typing.Optional[bool] = None,
+        reason: typing.Optional[str] = None,
+    ) -> None:
+        """Page.close
+
+        If `runBeforeUnload` is `false`, does not run any unload handlers and waits for the page to be closed. If
+        `runBeforeUnload` 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` is passed as true, a `beforeunload` dialog might be summoned and should be handled
+        manually via `page.on('dialog')` event.
+
+        Parameters
+        ----------
+        run_before_unload : Union[bool, None]
+            Defaults to `false`. Whether to run the
+            [before unload](https://developer.mozilla.org/en-US/docs/Web/Events/beforeunload) page handlers.
+        reason : Union[str, None]
+            The reason to be reported to the operations interrupted by the page closure.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.close(runBeforeUnload=run_before_unload, reason=reason)
+            )
+        )
+
+    def is_closed(self) -> bool:
+        """Page.is_closed
+
+        Indicates that the page has been closed.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.is_closed())
+
+    def click(
+        self,
+        selector: str,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.click
+
+        This method clicks an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to click in the center of the element, or the specified `position`.
+        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
+            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
+        button : Union["left", "middle", "right", None]
+            Defaults to `left`.
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        strict : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.click(
+                    selector=selector,
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    clickCount=click_count,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
+                    strict=strict,
+                )
+            )
+        )
+
+    def dblclick(
+        self,
+        selector: str,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.dblclick
+
+        This method double clicks an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to double click in the center of the element, or the specified `position`.
+
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **NOTE** `page.dblclick()` dispatches two `click` events and a single `dblclick` event.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
+            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
+        button : Union["left", "middle", "right", None]
+            Defaults to `left`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.dblclick(
+                    selector=selector,
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
+
+    def tap(
+        self,
+        selector: str,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.tap
+
+        This method taps an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to tap the center of the element, or the specified `position`.
+
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **NOTE** `page.tap()` the method will throw if `hasTouch` option of the browser context is false.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.tap(
+                    selector=selector,
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
+
+    def fill(
+        self,
+        selector: str,
+        value: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.fill
+
+        This method waits for an element matching `selector`, waits for [actionability](https://playwright.dev/python/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.press_sequentially()`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        value : str
+            Value to fill for the `<input>`, `<textarea>` or `[contenteditable]` element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.fill(
+                    selector=selector,
+                    value=value,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    force=force,
+                )
+            )
+        )
+
+    def locator(
+        self,
+        selector: str,
+        *,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has: typing.Optional["Locator"] = None,
+        has_not: typing.Optional["Locator"] = None,
+    ) -> "Locator":
+        """Page.locator
+
+        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/python/docs/locators).
+
+        Parameters
+        ----------
+        selector : str
+            A selector to use when resolving DOM element.
+        has_text : Union[Pattern[str], str, None]
+            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>`.
+        has_not_text : Union[Pattern[str], str, None]
+            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.
+        has : Union[Locator, None]
+            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`s.
+        has_not : Union[Locator, None]
+            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`s.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.locator(
+                selector=selector,
+                hasText=has_text,
+                hasNotText=has_not_text,
+                has=has._impl_obj if has else None,
+                hasNot=has_not._impl_obj if has_not else None,
+            )
+        )
+
+    def get_by_alt_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Page.get_by_alt_text
+
+        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'>
+        ```
+
+        ```py
+        page.get_by_alt_text(\"Playwright logo\").click()
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_alt_text(text=text, exact=exact))
+
+    def get_by_label(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Page.get_by_label
+
+        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\">
+        ```
+
+        ```py
+        page.get_by_label(\"Username\").fill(\"john\")
+        page.get_by_label(\"Password\").fill(\"secret\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_label(text=text, exact=exact))
+
+    def get_by_placeholder(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Page.get_by_placeholder
+
+        Allows locating input elements by the placeholder text.
+
+        **Usage**
+
+        For example, consider the following DOM structure.
+
+        ```html
+        <input type=\"email\" placeholder=\"name@example.com\" />
+        ```
+
+        You can fill the input after locating it by the placeholder text:
+
+        ```py
+        page.get_by_placeholder(\"name@example.com\").fill(\"playwright@microsoft.com\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_placeholder(text=text, exact=exact)
+        )
+
+    def get_by_role(
+        self,
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
+        ],
+        *,
+        checked: typing.Optional[bool] = None,
+        disabled: typing.Optional[bool] = None,
+        expanded: typing.Optional[bool] = None,
+        include_hidden: typing.Optional[bool] = None,
+        level: typing.Optional[int] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        pressed: typing.Optional[bool] = None,
+        selected: typing.Optional[bool] = None,
+        exact: typing.Optional[bool] = None,
+        description: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> "Locator":
+        """Page.get_by_role
+
+        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 its implicit role:
+
+        ```py
+        expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
+
+        page.get_by_role(\"checkbox\", name=\"Subscribe\").check()
+
+        page.get_by_role(\"button\", name=re.compile(\"submit\", re.IGNORECASE)).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.
+
+        Parameters
+        ----------
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        checked : Union[bool, None]
+            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).
+        disabled : Union[bool, None]
+            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).
+
+        expanded : Union[bool, None]
+            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).
+        include_hidden : Union[bool, None]
+            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).
+        level : Union[int, None]
+            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).
+        name : Union[Pattern[str], str, None]
+            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` to control this behavior.
+
+            Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
+        pressed : Union[bool, None]
+            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).
+        selected : Union[bool, None]
+            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).
+        exact : Union[bool, None]
+            Whether `name` and `description` are matched exactly: case-sensitive and whole-string. Defaults to false. Ignored
+            when the value is a regular expression. Note that exact match still trims whitespace.
+        description : Union[Pattern[str], str, None]
+            Option to match the [accessible description](https://w3c.github.io/accname/#dfn-accessible-description). By
+            default, matching is case-insensitive and searches for a substring, use `exact` to control this behavior.
+
+            Learn more about [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_role(
+                role=role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=include_hidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
+
+    def get_by_test_id(
+        self, test_id: typing.Union[str, typing.Pattern[str]]
+    ) -> "Locator":
+        """Page.get_by_test_id
+
+        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 its test id:
+
+        ```py
+        page.get_by_test_id(\"directions\").click()
+        ```
+
+        **Details**
+
+        By default, the `data-testid` attribute is used as a test id. Use `selectors.set_test_id_attribute()` to
+        configure a different test id attribute if necessary.
+
+        Parameters
+        ----------
+        test_id : Union[Pattern[str], str]
+            Id to locate the element by.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_test_id(testId=test_id))
+
+    def get_by_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Page.get_by_text
+
+        Allows locating elements that contain given text.
+
+        See also `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:
+
+        ```py
+        # Matches <span>
+        page.get_by_text(\"world\")
+
+        # Matches first <div>
+        page.get_by_text(\"Hello world\")
+
+        # Matches second <div>
+        page.get_by_text(\"Hello\", exact=True)
+
+        # Matches both <div>s
+        page.get_by_text(re.compile(\"Hello\"))
+
+        # Matches second <div>
+        page.get_by_text(re.compile(\"^hello$\", re.IGNORECASE))
+        ```
+
+        **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\">`.
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_text(text=text, exact=exact))
+
+    def get_by_title(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Page.get_by_title
+
+        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:
+
+        ```py
+        expect(page.get_by_title(\"Issues count\")).to_have_text(\"25 issues\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_title(text=text, exact=exact))
+
+    def frame_locator(self, selector: str) -> "FrameLocator":
+        """Page.frame_locator
+
+        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\">`:
+
+        ```py
+        locator = page.frame_locator(\"#my-iframe\").get_by_text(\"Submit\")
+        locator.click()
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to use when resolving DOM element.
+
+        Returns
+        -------
+        FrameLocator
+        """
+
+        return mapping.from_impl(self._impl_obj.frame_locator(selector=selector))
+
+    def focus(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Page.focus
+
+        This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the
+        method waits until a matching element appears in the DOM.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.focus(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def text_content(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Page.text_content
+
+        Returns `element.textContent`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.text_content(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def inner_text(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Page.inner_text
+
+        Returns `element.innerText`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.inner_text(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def inner_html(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Page.inner_html
+
+        Returns `element.innerHTML`.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.inner_html(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def get_attribute(
+        self,
+        selector: str,
+        name: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Page.get_attribute
+
+        Returns element attribute value.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        name : str
+            Attribute name to get the value for.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        Union[str, None]
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.get_attribute(
+                    selector=selector,
+                    name=name,
+                    strict=strict,
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
+
+    def hover(
+        self,
+        selector: str,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.hover
+
+        This method hovers over an element matching `selector` by performing the following steps:
+        1. Find an element matching `selector`. If there is none, wait until a matching element is attached to the DOM.
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the matched element, unless `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` to hover over the center of the element, or the specified `position`.
+
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.hover(
+                    selector=selector,
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    force=force,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
+
+    def drag_and_drop(
+        self,
+        source: str,
+        target: str,
+        *,
+        source_position: typing.Optional[Position] = None,
+        target_position: typing.Optional[Position] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
+        """Page.drag_and_drop
+
+        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**
+
+        ```py
+        page.drag_and_drop(\"#source\", \"#target\")
+        # or specify exact positions relative to the top-left corners of the elements:
+        page.drag_and_drop(
+          \"#source\",
+          \"#target\",
+          source_position={\"x\": 34, \"y\": 7},
+          target_position={\"x\": 10, \"y\": 20}
+        )
+        ```
+
+        Parameters
+        ----------
+        source : str
+            A selector to search for an element to drag. If there are multiple elements satisfying the selector, the first will
+            be used.
+        target : str
+            A selector to search for an element to drop onto. If there are multiple elements satisfying the selector, the first
+            will be used.
+        source_position : Union[{x: float, y: float}, None]
+            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.
+        target_position : Union[{x: float, y: float}, None]
+            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.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.drag_and_drop(
+                    source=source,
+                    target=target,
+                    sourcePosition=source_position,
+                    targetPosition=target_position,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    timeout=to_milliseconds(timeout),
+                    strict=strict,
+                    trial=trial,
+                    steps=steps,
+                )
+            )
+        )
+
+    def select_option(
+        self,
+        selector: str,
+        value: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        *,
+        index: typing.Optional[typing.Union[int, typing.Sequence[int]]] = None,
+        label: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        element: typing.Optional[
+            typing.Union["ElementHandle", typing.Sequence["ElementHandle"]]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> typing.List[str]:
+        """Page.select_option
+
+        This method waits for an element matching `selector`, waits for [actionability](https://playwright.dev/python/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**
+
+        ```py
+        # Single selection matching the value or label
+        page.select_option(\"select#colors\", \"blue\")
+        # single selection matching both the label
+        page.select_option(\"select#colors\", label=\"blue\")
+        # multiple selection
+        page.select_option(\"select#colors\", value=[\"red\", \"green\", \"blue\"])
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        value : Union[Sequence[str], str, None]
+            Options to select by value. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        index : Union[Sequence[int], int, None]
+            Options to select by index. Optional.
+        label : Union[Sequence[str], str, None]
+            Options to select by label. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        element : Union[ElementHandle, Sequence[ElementHandle], None]
+            Option elements to select. Optional.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        strict : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        List[str]
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.select_option(
+                    selector=selector,
+                    value=mapping.to_impl(value),
+                    index=mapping.to_impl(index),
+                    label=mapping.to_impl(label),
+                    element=mapping.to_impl(element),
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    force=force,
+                    strict=strict,
+                )
+            )
+        )
+
+    def input_value(
+        self,
+        selector: str,
+        *,
+        strict: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Page.input_value
+
+        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.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        strict : Union[bool, None]
+            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.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.input_value(
+                    selector=selector, strict=strict, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def set_input_files(
+        self,
+        selector: str,
+        files: typing.Union[
+            str,
+            pathlib.Path,
+            FilePayload,
+            typing.Sequence[typing.Union[str, pathlib.Path]],
+            typing.Sequence[FilePayload],
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        strict: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.set_input_files
+
+        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` 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.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        files : Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}]
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        strict : Union[bool, None]
+            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.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_input_files(
+                    selector=selector,
+                    files=mapping.to_impl(files),
+                    timeout=to_milliseconds(timeout),
+                    strict=strict,
+                    noWaitAfter=no_wait_after,
+                )
+            )
+        )
+
+    def type(
+        self,
+        selector: str,
+        text: str,
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.type
+
+        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()`.
+
+        To press a special key, like `Control` or `ArrowDown`, use `keyboard.press()`.
+
+        **Usage**
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        text : str
+            A text to type into a focused element.
+        delay : Union[float, None]
+            Time to wait between key presses in milliseconds. Defaults to 0.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.type(
+                    selector=selector,
+                    text=text,
+                    delay=delay,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                )
+            )
+        )
+
+    def press(
+        self,
+        selector: str,
+        key: str,
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.press
+
+        Focuses the element, and then uses `keyboard.down()` and `keyboard.up()`.
+
+        `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` 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` in the upper case.
+
+        If `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**
+
+        ```py
+        page = browser.new_page()
+        page.goto(\"https://keycode.info\")
+        page.press(\"body\", \"A\")
+        page.screenshot(path=\"a.png\")
+        page.press(\"body\", \"ArrowLeft\")
+        page.screenshot(path=\"arrow_left.png\")
+        page.press(\"body\", \"Shift+O\")
+        page.screenshot(path=\"o.png\")
+        browser.close()
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        key : str
+            Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
+        delay : Union[float, None]
+            Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            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.
+        strict : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.press(
+                    selector=selector,
+                    key=key,
+                    delay=delay,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                )
+            )
+        )
+
+    def check(
+        self,
+        selector: str,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.check
+
+        This method checks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.check(
+                    selector=selector,
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
+
+    def uncheck(
+        self,
+        selector: str,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.uncheck
+
+        This method unchecks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.uncheck(
+                    selector=selector,
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
+
+    def wait_for_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """Page.wait_for_timeout
+
+        Waits for the given `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**
+
+        ```py
+        # wait for 1 second
+        page.wait_for_timeout(1000)
+        ```
+
+        Parameters
+        ----------
+        timeout : float
+            A timeout to wait for
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_timeout(timeout=to_milliseconds(timeout))
+            )
+        )
+
+    def wait_for_function(
+        self,
+        expression: str,
+        *,
+        arg: typing.Optional[typing.Any] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        polling: typing.Optional[typing.Union[float, Literal["raf"]]] = None,
+    ) -> "JSHandle":
+        """Page.wait_for_function
+
+        Returns when the `expression` returns a truthy value. It resolves to a JSHandle of the truthy value.
+
+        **Usage**
+
+        The `page.wait_for_function()` can be used to observe viewport size change:
+
+        ```py
+        from playwright.sync_api import sync_playwright, Playwright
+
+        def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = webkit.launch()
+            page = browser.new_page()
+            page.evaluate(\"window.x = 0; setTimeout(() => { window.x = 100 }, 1000);\")
+            page.wait_for_function(\"() => window.x > 0\")
+            browser.close()
+
+        with sync_playwright() as playwright:
+            run(playwright)
+        ```
+
+        To pass an argument to the predicate of `page.wait_for_function()` function:
+
+        ```py
+        selector = \".foo\"
+        page.wait_for_function(\"selector => !!document.querySelector(selector)\", selector)
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()` or
+            `page.set_default_timeout()` methods.
+        polling : Union["raf", float, None]
+            If `polling` is `'raf'`, then `expression` is constantly executed in `requestAnimationFrame` callback. If `polling`
+            is a number, then it is treated as an interval in milliseconds at which the function would be executed. Defaults to
+            `raf`.
+
+        Returns
+        -------
+        JSHandle
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.wait_for_function(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    timeout=to_milliseconds(timeout),
+                    polling=polling,
+                )
+            )
+        )
+
+    def pause(self) -> None:
+        """Page.pause
+
+        Pauses script execution. Playwright will stop executing the script and wait for the user to either press the
+        '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` option.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.pause()))
+
+    def pdf(
+        self,
+        *,
+        scale: typing.Optional[float] = None,
+        display_header_footer: typing.Optional[bool] = None,
+        header_template: typing.Optional[str] = None,
+        footer_template: typing.Optional[str] = None,
+        print_background: typing.Optional[bool] = None,
+        landscape: typing.Optional[bool] = None,
+        page_ranges: typing.Optional[str] = None,
+        format: typing.Optional[str] = None,
+        width: typing.Optional[typing.Union[str, float]] = None,
+        height: typing.Optional[typing.Union[str, float]] = None,
+        prefer_css_page_size: typing.Optional[bool] = None,
+        margin: typing.Optional[PdfMargins] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        outline: typing.Optional[bool] = None,
+        tagged: typing.Optional[bool] = None,
+    ) -> bytes:
+        """Page.pdf
+
+        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.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**
+
+        ```py
+        # generates a pdf with \"screen\" media type.
+        page.emulate_media(media=\"screen\")
+        page.pdf(path=\"page.pdf\")
+        ```
+
+        The `width`, `height`, and `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` 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` and `footerTemplate` markup have the following limitations: > 1. Script tags inside
+        templates are not evaluated. > 2. Page styles are not visible inside templates.
+
+        Parameters
+        ----------
+        scale : Union[float, None]
+            Scale of the webpage rendering. Defaults to `1`. Scale amount must be between 0.1 and 2.
+        display_header_footer : Union[bool, None]
+            Display header and footer. Defaults to `false`.
+        header_template : Union[str, None]
+            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
+        footer_template : Union[str, None]
+            HTML template for the print footer. Should use the same format as the `headerTemplate`.
+        print_background : Union[bool, None]
+            Print background graphics. Defaults to `false`.
+        landscape : Union[bool, None]
+            Paper orientation. Defaults to `false`.
+        page_ranges : Union[str, None]
+            Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty string, which means print all pages.
+        format : Union[str, None]
+            Paper format. If set, takes priority over `width` or `height` options. Defaults to 'Letter'.
+        width : Union[float, str, None]
+            Paper width, accepts values labeled with units.
+        height : Union[float, str, None]
+            Paper height, accepts values labeled with units.
+        prefer_css_page_size : Union[bool, None]
+            Give any CSS `@page` size declared in the page priority over what is declared in `width` and `height` or `format`
+            options. Defaults to `false`, which will scale the content to fit the paper size.
+        margin : Union[{top: Union[float, str, None], right: Union[float, str, None], bottom: Union[float, str, None], left: Union[float, str, None]}, None]
+            Paper margins, defaults to none.
+        path : Union[pathlib.Path, str, None]
+            The file path to save the PDF to. If `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.
+        outline : Union[bool, None]
+            Whether or not to embed the document outline into the PDF. Defaults to `false`.
+        tagged : Union[bool, None]
+            Whether or not to generate tagged (accessible) PDF. Defaults to `false`.
+
+        Returns
+        -------
+        bytes
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.pdf(
+                    scale=scale,
+                    displayHeaderFooter=display_header_footer,
+                    headerTemplate=header_template,
+                    footerTemplate=footer_template,
+                    printBackground=print_background,
+                    landscape=landscape,
+                    pageRanges=page_ranges,
+                    format=format,
+                    width=width,
+                    height=height,
+                    preferCSSPageSize=prefer_css_page_size,
+                    margin=margin,
+                    path=path,
+                    outline=outline,
+                    tagged=tagged,
+                )
+            )
+        )
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["ConsoleMessage"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["crash"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Dialog"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["domcontentloaded"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Download"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["filechooser"],
+        predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["FileChooser"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["load"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["pageerror"],
+        predicate: typing.Optional[typing.Callable[["Error"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Error"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["popup"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Response"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["websocket"],
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["WebSocket"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["worker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager[typing.Any]: ...
+
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager:
+        """Page.expect_event
+
+        Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+        value. Will throw an error if the page is closed before the event is fired. Returns the event data value.
+
+        **Usage**
+
+        ```py
+        with page.expect_event(\"framenavigated\") as event_info:
+            page.get_by_role(\"button\")
+        frame = event_info.value
+        ```
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_event(
+                event=event,
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def expect_console_message(
+        self,
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["ConsoleMessage"]:
+        """Page.expect_console_message
+
+        Performs action and waits for a `ConsoleMessage` to be logged by in the page. If predicate is provided, it passes
+        `ConsoleMessage` value into the `predicate` function and waits for `predicate(message)` to return a truthy value.
+        Will throw an error if the page is closed before the `page.on('console')` event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[ConsoleMessage], bool], None]
+            Receives the `ConsoleMessage` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[ConsoleMessage]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_console_message(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def expect_download(
+        self,
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["Download"]:
+        """Page.expect_download
+
+        Performs action and waits for a new `Download`. If predicate is provided, it passes `Download` value into the
+        `predicate` function and waits for `predicate(download)` to return a truthy value. Will throw an error if the page
+        is closed before the download event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[Download], bool], None]
+            Receives the `Download` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[Download]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_download(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def expect_file_chooser(
+        self,
+        predicate: typing.Optional[typing.Callable[["FileChooser"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["FileChooser"]:
+        """Page.expect_file_chooser
+
+        Performs action and waits for a new `FileChooser` to be created. If predicate is provided, it passes `FileChooser`
+        value into the `predicate` function and waits for `predicate(fileChooser)` to return a truthy value. Will throw an
+        error if the page is closed before the file chooser is opened.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[FileChooser], bool], None]
+            Receives the `FileChooser` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[FileChooser]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_file_chooser(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def expect_navigation(
+        self,
+        *,
+        url: typing.Optional[
+            typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]]
+        ] = None,
+        wait_until: typing.Optional[
+            Literal["commit", "domcontentloaded", "load", "networkidle"]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["Response"]:
+        """Page.expect_navigation
+
+        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:
+
+        ```py
+        with page.expect_navigation():
+            # This action triggers the navigation after a timeout.
+            page.get_by_text(\"Navigate after timeout\").click()
+        # Resolves after navigation has finished
+        ```
+
+        **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.
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str, None]
+            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.
+        wait_until : Union["commit", "domcontentloaded", "load", "networkidle", None]
+            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.
+        timeout : Union[float, None]
+            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_navigation_timeout()`,
+            `browser_context.set_default_timeout()`, `page.set_default_navigation_timeout()` or
+            `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        EventContextManager[Response]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_navigation(
+                url=self._wrap_handler(url),
+                waitUntil=wait_until,
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def expect_popup(
+        self,
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["Page"]:
+        """Page.expect_popup
+
+        Performs action and waits for a popup `Page`. If predicate is provided, it passes [Popup] value into the
+        `predicate` function and waits for `predicate(page)` to return a truthy value. Will throw an error if the page is
+        closed before the popup event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[Page], bool], None]
+            Receives the `Page` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[Page]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_popup(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def expect_request(
+        self,
+        url_or_predicate: typing.Union[
+            str, typing.Pattern[str], typing.Callable[["Request"], bool]
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["Request"]:
+        """Page.expect_request
+
+        Waits for the matching request and returns it. See [waiting for event](https://playwright.dev/python/docs/events#waiting-for-event) for more
+        details about events.
+
+        **Usage**
+
+        ```py
+        with page.expect_request(\"http://example.com/resource\") as first:
+            page.get_by_text(\"trigger request\").click()
+        first_request = first.value
+
+        # or with a lambda
+        with page.expect_request(lambda request: request.url == \"http://example.com\" and request.method == \"get\") as second:
+            page.get_by_text(\"trigger request\").click()
+        second_request = second.value
+        ```
+
+        Parameters
+        ----------
+        url_or_predicate : Union[Callable[[Request], bool], Pattern[str], str]
+            Request URL string, regex or predicate receiving `Request` object. When a `baseURL` 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.
+        timeout : Union[float, None]
+            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.set_default_timeout()` method.
+
+        Returns
+        -------
+        EventContextManager[Request]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_request(
+                urlOrPredicate=self._wrap_handler(url_or_predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def expect_request_finished(
+        self,
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["Request"]:
+        """Page.expect_request_finished
+
+        Performs action and waits for a `Request` to finish loading. If predicate is provided, it passes `Request` value
+        into the `predicate` function and waits for `predicate(request)` to return a truthy value. Will throw an error if
+        the page is closed before the `page.on('request_finished')` event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[Request], bool], None]
+            Receives the `Request` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[Request]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_request_finished(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def expect_response(
+        self,
+        url_or_predicate: typing.Union[
+            str, typing.Pattern[str], typing.Callable[["Response"], bool]
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["Response"]:
+        """Page.expect_response
+
+        Returns the matched response. See [waiting for event](https://playwright.dev/python/docs/events#waiting-for-event) for more details about
+        events.
+
+        **Usage**
+
+        ```py
+        with page.expect_response(\"https://example.com/resource\") as response_info:
+            page.get_by_text(\"trigger response\").click()
+        response = response_info.value
+        return response.ok
+
+        # or with a lambda
+        with page.expect_response(lambda response: response.url == \"https://example.com\" and response.status == 200 and response.request.method == \"get\") as response_info:
+            page.get_by_text(\"trigger response\").click()
+        response = response_info.value
+        return response.ok
+        ```
+
+        Parameters
+        ----------
+        url_or_predicate : Union[Callable[[Response], bool], Pattern[str], str]
+            Request URL string, regex or predicate receiving `Response` object. When a `baseURL` 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.
+        timeout : Union[float, None]
+            Maximum wait time in milliseconds, defaults to 30 seconds, pass `0` to disable the timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        EventContextManager[Response]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_response(
+                urlOrPredicate=self._wrap_handler(url_or_predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def expect_websocket(
+        self,
+        predicate: typing.Optional[typing.Callable[["WebSocket"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["WebSocket"]:
+        """Page.expect_websocket
+
+        Performs action and waits for a new `WebSocket`. If predicate is provided, it passes `WebSocket` value into the
+        `predicate` function and waits for `predicate(webSocket)` to return a truthy value. Will throw an error if the page
+        is closed before the WebSocket event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[WebSocket], bool], None]
+            Receives the `WebSocket` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[WebSocket]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_websocket(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def expect_worker(
+        self,
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["Worker"]:
+        """Page.expect_worker
+
+        Performs action and waits for a new `Worker`. If predicate is provided, it passes `Worker` value into the
+        `predicate` function and waits for `predicate(worker)` to return a truthy value. Will throw an error if the page is
+        closed before the worker event is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[Worker], bool], None]
+            Receives the `Worker` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[Worker]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_worker(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def set_checked(
+        self,
+        selector: str,
+        checked: bool,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        strict: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Page.set_checked
+
+        This method checks or unchecks an element matching `selector` by performing the following steps:
+        1. Find an element matching `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/python/docs/actionability) checks on the matched element, unless `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` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        selector : str
+            A selector to search for an element. If there are multiple elements satisfying the selector, the first will be
+            used.
+        checked : bool
+            Whether to check or uncheck the checkbox.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        strict : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_checked(
+                    selector=selector,
+                    checked=checked,
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    strict=strict,
+                    trial=trial,
+                )
+            )
+        )
+
+    def add_locator_handler(
+        self,
+        locator: "Locator",
+        handler: typing.Union[
+            typing.Callable[["Locator"], typing.Any], typing.Callable[[], typing.Any]
+        ],
+        *,
+        no_wait_after: typing.Optional[bool] = None,
+        times: typing.Optional[int] = None,
+    ) -> None:
+        """Page.add_locator_handler
+
+        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.add_locator_handler()`.
+        - Playwright checks for the overlay every time before executing or retrying an action that requires an
+          [actionability check](https://playwright.dev/python/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`.
+        - 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()` followed by `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()` instead to avoid this problem.
+
+        Another example is a series of mouse actions, where `mouse.move()` is followed by `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()` 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:
+
+        ```py
+        # Setup the handler.
+        async def handler():
+          await page.get_by_role(\"button\", name=\"No thanks\").click()
+        await page.add_locator_handler(page.get_by_text(\"Sign up to the newsletter\"), handler)
+
+        # Write the test as usual.
+        await page.goto(\"https://example.com\")
+        await page.get_by_role(\"button\", name=\"Start here\").click()
+        ```
+
+        An example that skips the \"Confirm your security details\" page when it is shown:
+
+        ```py
+        # Setup the handler.
+        async def handler():
+          await page.get_by_role(\"button\", name=\"Remind me later\").click()
+        await page.add_locator_handler(page.get_by_text(\"Confirm your security details\"), handler)
+
+        # Write the test as usual.
+        await page.goto(\"https://example.com\")
+        await page.get_by_role(\"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`, because the
+        handler does not hide the `<body>` element.
+
+        ```py
+        # Setup the handler.
+        async def handler():
+          await page.evaluate(\"window.removeObstructionsForTestIfNeeded()\")
+        await page.add_locator_handler(page.locator(\"body\"), handler, no_wait_after=True)
+
+        # Write the test as usual.
+        await page.goto(\"https://example.com\")
+        await page.get_by_role(\"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`:
+
+        ```py
+        async def handler(locator):
+          await locator.click()
+        await page.add_locator_handler(page.get_by_label(\"Close\"), handler, times=1)
+        ```
+
+        Parameters
+        ----------
+        locator : Locator
+            Locator that triggers the handler.
+        handler : Union[Callable[[Locator], Any], Callable[[], Any]]
+            Function that should be run once `locator` appears. This function should get rid of the element that blocks actions
+            like click.
+        no_wait_after : Union[bool, None]
+            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.
+        times : Union[int, None]
+            Specifies the maximum number of times this handler should be called. Unlimited by default.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.add_locator_handler(
+                    locator=locator._impl_obj,
+                    handler=self._wrap_handler(handler),
+                    noWaitAfter=no_wait_after,
+                    times=times,
+                )
+            )
+        )
+
+    def remove_locator_handler(self, locator: "Locator") -> None:
+        """Page.remove_locator_handler
+
+        Removes all locator handlers added by `page.add_locator_handler()` for a specific locator.
+
+        Parameters
+        ----------
+        locator : Locator
+            Locator passed to `page.add_locator_handler()`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.remove_locator_handler(locator=locator._impl_obj))
+        )
+
+    def requests(self) -> typing.List["Request"]:
+        """Page.requests
+
+        Returns up to (currently) 100 last network request from this page. See `page.on('request')` for more details.
+
+        Returned requests should be accessed immediately, otherwise they might be collected to prevent unbounded memory
+        growth as new requests come in. Once collected, retrieving most information about the request is impossible.
+
+        Note that requests reported through the `page.on('request')` request are not collected, so there is a trade off
+        between efficient memory usage with `page.requests()` and the amount of available information reported
+        through `page.on('request')`.
+
+        Returns
+        -------
+        List[Request]
+        """
+
+        return mapping.from_impl_list(self._sync(self._impl_obj.requests()))
+
+    def console_messages(
+        self, *, filter: typing.Optional[Literal["all", "since-navigation"]] = None
+    ) -> typing.List["ConsoleMessage"]:
+        """Page.console_messages
+
+        Returns up to (currently) 200 last console messages from this page. See `page.on('console')` for more details.
+
+        Parameters
+        ----------
+        filter : Union["all", "since-navigation", None]
+            Controls which messages are returned:
+
+        Returns
+        -------
+        List[ConsoleMessage]
+        """
+
+        return mapping.from_impl_list(
+            self._sync(self._impl_obj.console_messages(filter=filter))
+        )
+
+    def page_errors(
+        self, *, filter: typing.Optional[Literal["all", "since-navigation"]] = None
+    ) -> typing.List["Error"]:
+        """Page.page_errors
+
+        Returns up to (currently) 200 last page errors from this page. See `page.on('page_error')` for more details.
+
+        Parameters
+        ----------
+        filter : Union["all", "since-navigation", None]
+            Controls which errors are returned:
+
+        Returns
+        -------
+        List[Error]
+        """
+
+        return mapping.from_impl_list(
+            self._sync(self._impl_obj.page_errors(filter=filter))
+        )
+
+    def clear_console_messages(self) -> None:
+        """Page.clear_console_messages
+
+        Clears all stored console messages from this page. Subsequent calls to `page.console_messages()` will only
+        return messages logged after the clear.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.clear_console_messages())
+        )
+
+    def clear_page_errors(self) -> None:
+        """Page.clear_page_errors
+
+        Clears all stored page errors from this page. Subsequent calls to `page.page_errors()` will only return
+        errors thrown after the clear.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.clear_page_errors()))
+
+    def pick_locator(self) -> "Locator":
+        """Page.pick_locator
+
+        Enters pick locator mode where hovering over page elements highlights them and shows the corresponding locator.
+        Once the user clicks an element, the mode is deactivated and the `Locator` for the picked element is returned.
+
+        **Usage**
+
+        ```py
+        locator = page.pick_locator()
+        print(locator)
+        ```
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._sync(self._impl_obj.pick_locator()))
+
+    def cancel_pick_locator(self) -> None:
+        """Page.cancel_pick_locator
+
+        Cancels an ongoing `page.pick_locator()` call by deactivating pick locator mode. If no pick locator mode is
+        active, this method is a no-op.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.cancel_pick_locator()))
+
+
+mapping.register(PageImpl, Page)
+
+
+class WebError(SyncBase):
+
+    @property
+    def page(self) -> typing.Optional["Page"]:
+        """WebError.page
+
+        The page that produced this unhandled exception, if any.
+
+        Returns
+        -------
+        Union[Page, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.page)
+
+    @property
+    def error(self) -> "Error":
+        """WebError.error
+
+        Unhandled error that was thrown.
+
+        Returns
+        -------
+        Error
+        """
+        return mapping.from_impl(self._impl_obj.error)
+
+    @property
+    def location(self) -> WebErrorLocation:
+        """WebError.location
+
+        Returns
+        -------
+        {url: str, line: int, column: int}
+        """
+        return mapping.from_impl(self._impl_obj.location)
+
+
+mapping.register(WebErrorImpl, WebError)
+
+
+class BrowserContext(SyncContextManager):
+
+    @typing.overload
+    def on(
+        self, event: Literal["backgroundpage"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        This event is not emitted."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["close"], f: typing.Callable[["BrowserContext"], "None"]
+    ) -> None:
+        """
+        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()` method was called."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
+    ) -> None:
+        """
+        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` event handler argument.
+
+        **Usage**
+
+        ```py
+        def print_args(msg):
+            for arg in msg.args:
+                print(arg.json_value())
+
+        context.on(\"console\", print_args)
+        page.evaluate(\"console.log('hello', 5, { foo: 'bar' })\")
+        ```"""
+
+    @typing.overload
+    def on(
+        self, event: Literal["dialog"], f: typing.Callable[["Dialog"], "None"]
+    ) -> None:
+        """
+        Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**
+        either `dialog.accept()` or `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**
+
+        ```python
+        context.on(\"dialog\", lambda dialog: dialog.accept())
+        ```
+
+        **NOTE** When no `page.on('dialog')` or `browser_context.on('dialog')` listeners are present, all dialogs are
+        automatically dismissed."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["download"], f: typing.Callable[["Download"], "None"]
+    ) -> None:
+        """
+        Emitted when attachment download started in any page belonging to this context. User can access basic file
+        operations on downloaded content via the passed `Download` instance. See also `page.on('download')` to receive
+        events about a specific page."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["frameattached"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is attached in any page belonging to this context. See also `page.on('frame_attached')` to
+        receive events about a specific page."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["framedetached"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is detached in any page belonging to this context. See also `page.on('frame_detached')` to
+        receive events about a specific page."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["framenavigated"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is navigated to a new url in any page belonging to this context. See also
+        `page.on('frame_navigated')` to receive events about navigations in a specific page.
+        """
+
+    @typing.overload
+    def on(self, event: Literal["page"], f: typing.Callable[["Page"], "None"]) -> None:
+        """
+        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')` 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 `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
+
+        ```py
+        with context.expect_page() as page_info:
+            page.get_by_text(\"open new page\").click(),
+        page = page_info.value
+        print(page.evaluate(\"location.href\"))
+        ```
+
+        **NOTE** Use `page.wait_for_load_state()` to wait until the page gets to a particular state (you should not
+        need it in most cases)."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["pageclose"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        Emitted when a page in this context is closed. See also `page.on('close')` to receive events about a specific
+        page."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["pageload"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched
+        in any page belonging to this context. See also `page.on('load')` to receive events about a specific page.
+        """
+
+    @typing.overload
+    def on(
+        self, event: Literal["weberror"], f: typing.Callable[["WebError"], "None"]
+    ) -> None:
+        """
+        Emitted when exception is unhandled in any of the pages in this context. To listen for errors from a particular
+        page, use `page.on('page_error')` instead."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["request"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        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')`.
+
+        In order to intercept and mutate requests, see `browser_context.route()` or `page.route()`.
+        """
+
+    @typing.overload
+    def on(
+        self, event: Literal["requestfailed"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        Emitted when a request fails, for example by timing out. To only listen for failed requests from a particular page,
+        use `page.on('request_failed')`.
+
+        **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request
+        will complete with `browser_context.on('request_finished')` event and not with
+        `browser_context.on('request_failed')`."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["requestfinished"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        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('request_finished')`."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["response"], f: typing.Callable[["Response"], "None"]
+    ) -> None:
+        """
+        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')`."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["serviceworker"], f: typing.Callable[["Worker"], "None"]
+    ) -> None:
+        """
+        **NOTE** Service workers are only supported on Chromium-based browsers.
+
+        Emitted when new service worker is created in the context."""
+
+    def on(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self, event: Literal["backgroundpage"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        This event is not emitted."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["close"], f: typing.Callable[["BrowserContext"], "None"]
+    ) -> None:
+        """
+        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()` method was called."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["console"], f: typing.Callable[["ConsoleMessage"], "None"]
+    ) -> None:
+        """
+        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` event handler argument.
+
+        **Usage**
+
+        ```py
+        def print_args(msg):
+            for arg in msg.args:
+                print(arg.json_value())
+
+        context.on(\"console\", print_args)
+        page.evaluate(\"console.log('hello', 5, { foo: 'bar' })\")
+        ```"""
+
+    @typing.overload
+    def once(
+        self, event: Literal["dialog"], f: typing.Callable[["Dialog"], "None"]
+    ) -> None:
+        """
+        Emitted when a JavaScript dialog appears, such as `alert`, `prompt`, `confirm` or `beforeunload`. Listener **must**
+        either `dialog.accept()` or `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**
+
+        ```python
+        context.on(\"dialog\", lambda dialog: dialog.accept())
+        ```
+
+        **NOTE** When no `page.on('dialog')` or `browser_context.on('dialog')` listeners are present, all dialogs are
+        automatically dismissed."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["download"], f: typing.Callable[["Download"], "None"]
+    ) -> None:
+        """
+        Emitted when attachment download started in any page belonging to this context. User can access basic file
+        operations on downloaded content via the passed `Download` instance. See also `page.on('download')` to receive
+        events about a specific page."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["frameattached"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is attached in any page belonging to this context. See also `page.on('frame_attached')` to
+        receive events about a specific page."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["framedetached"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is detached in any page belonging to this context. See also `page.on('frame_detached')` to
+        receive events about a specific page."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["framenavigated"], f: typing.Callable[["Frame"], "None"]
+    ) -> None:
+        """
+        Emitted when a frame is navigated to a new url in any page belonging to this context. See also
+        `page.on('frame_navigated')` to receive events about navigations in a specific page.
+        """
+
+    @typing.overload
+    def once(
+        self, event: Literal["page"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        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')` 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 `browser_context.route()` and `browser_context.on('request')` respectively
+        instead of similar methods on the `Page`.
+
+        ```py
+        with context.expect_page() as page_info:
+            page.get_by_text(\"open new page\").click(),
+        page = page_info.value
+        print(page.evaluate(\"location.href\"))
+        ```
+
+        **NOTE** Use `page.wait_for_load_state()` to wait until the page gets to a particular state (you should not
+        need it in most cases)."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["pageclose"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        Emitted when a page in this context is closed. See also `page.on('close')` to receive events about a specific
+        page."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["pageload"], f: typing.Callable[["Page"], "None"]
+    ) -> None:
+        """
+        Emitted when the JavaScript [`load`](https://developer.mozilla.org/en-US/docs/Web/Events/load) event is dispatched
+        in any page belonging to this context. See also `page.on('load')` to receive events about a specific page.
+        """
+
+    @typing.overload
+    def once(
+        self, event: Literal["weberror"], f: typing.Callable[["WebError"], "None"]
+    ) -> None:
+        """
+        Emitted when exception is unhandled in any of the pages in this context. To listen for errors from a particular
+        page, use `page.on('page_error')` instead."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["request"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        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')`.
+
+        In order to intercept and mutate requests, see `browser_context.route()` or `page.route()`.
+        """
+
+    @typing.overload
+    def once(
+        self, event: Literal["requestfailed"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        Emitted when a request fails, for example by timing out. To only listen for failed requests from a particular page,
+        use `page.on('request_failed')`.
+
+        **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request
+        will complete with `browser_context.on('request_finished')` event and not with
+        `browser_context.on('request_failed')`."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["requestfinished"], f: typing.Callable[["Request"], "None"]
+    ) -> None:
+        """
+        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('request_finished')`."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["response"], f: typing.Callable[["Response"], "None"]
+    ) -> None:
+        """
+        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')`."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["serviceworker"], f: typing.Callable[["Worker"], "None"]
+    ) -> None:
+        """
+        **NOTE** Service workers are only supported on Chromium-based browsers.
+
+        Emitted when new service worker is created in the context."""
+
+    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def pages(self) -> typing.List["Page"]:
+        """BrowserContext.pages
+
+        Returns all open pages in the context.
+
+        Returns
+        -------
+        List[Page]
+        """
+        return mapping.from_impl_list(self._impl_obj.pages)
+
+    @property
+    def browser(self) -> typing.Optional["Browser"]:
+        """BrowserContext.browser
+
+        Gets the browser instance that owns the context. Returns `null` if the context is created outside of normal
+        browser, e.g. Android or Electron.
+
+        Returns
+        -------
+        Union[Browser, None]
+        """
+        return mapping.from_impl_nullable(self._impl_obj.browser)
+
+    @property
+    def background_pages(self) -> typing.List["Page"]:
+        """BrowserContext.background_pages
+
+        Returns an empty list.
+
+        Returns
+        -------
+        List[Page]
+        """
+        return mapping.from_impl_list(self._impl_obj.background_pages)
+
+    @property
+    def service_workers(self) -> typing.List["Worker"]:
+        """BrowserContext.service_workers
+
+        **NOTE** Service workers are only supported on Chromium-based browsers.
+
+        All existing service workers in the context.
+
+        Returns
+        -------
+        List[Worker]
+        """
+        return mapping.from_impl_list(self._impl_obj.service_workers)
+
+    @property
+    def tracing(self) -> "Tracing":
+        """BrowserContext.tracing
+
+        Returns
+        -------
+        Tracing
+        """
+        return mapping.from_impl(self._impl_obj.tracing)
+
+    @property
+    def debugger(self) -> "Debugger":
+        """BrowserContext.debugger
+
+        Debugger allows to pause and resume the execution.
+
+        Returns
+        -------
+        Debugger
+        """
+        return mapping.from_impl(self._impl_obj.debugger)
+
+    @property
+    def request(self) -> "APIRequestContext":
+        """BrowserContext.request
+
+        API testing helper associated with this context. Requests made with this API will use context cookies.
+
+        Returns
+        -------
+        APIRequestContext
+        """
+        return mapping.from_impl(self._impl_obj.request)
+
+    @property
+    def clock(self) -> "Clock":
+        """BrowserContext.clock
+
+        Playwright has ability to mock clock and passage of time.
+
+        Returns
+        -------
+        Clock
+        """
+        return mapping.from_impl(self._impl_obj.clock)
+
+    def set_default_navigation_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """BrowserContext.set_default_navigation_timeout
+
+        This setting will change the default maximum navigation time for the following methods and related shortcuts:
+        - `page.go_back()`
+        - `page.go_forward()`
+        - `page.goto()`
+        - `page.reload()`
+        - `page.set_content()`
+        - `page.expect_navigation()`
+
+        **NOTE** `page.set_default_navigation_timeout()` and `page.set_default_timeout()` take priority over
+        `browser_context.set_default_navigation_timeout()`.
+
+        Parameters
+        ----------
+        timeout : float
+            Maximum navigation time in milliseconds
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_default_navigation_timeout(
+                timeout=to_milliseconds(timeout)
+            )
+        )
+
+    def set_default_timeout(
+        self, timeout: typing.Union[float, datetime.timedelta]
+    ) -> None:
+        """BrowserContext.set_default_timeout
+
+        This setting will change the default maximum time for all the methods accepting `timeout` option.
+
+        **NOTE** `page.set_default_navigation_timeout()`, `page.set_default_timeout()` and
+        `browser_context.set_default_navigation_timeout()` take priority over
+        `browser_context.set_default_timeout()`.
+
+        Parameters
+        ----------
+        timeout : float
+            Maximum time in milliseconds. Pass `0` to disable timeout.
+        """
+
+        return mapping.from_maybe_impl(
+            self._impl_obj.set_default_timeout(timeout=to_milliseconds(timeout))
+        )
+
+    def new_page(self) -> "Page":
+        """BrowserContext.new_page
+
+        Creates a new page in the browser context.
+
+        Returns
+        -------
+        Page
+        """
+
+        return mapping.from_impl(self._sync(self._impl_obj.new_page()))
+
+    def cookies(
+        self, urls: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None
+    ) -> typing.List[Cookie]:
+        """BrowserContext.cookies
+
+        If no URLs are specified, this method returns all cookies. If URLs are specified, only cookies that affect those
+        URLs are returned.
+
+        Parameters
+        ----------
+        urls : Union[Sequence[str], str, None]
+            Optional list of URLs.
+
+        Returns
+        -------
+        List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"], partitionKey: Union[str, None]}]
+        """
+
+        return mapping.from_impl_list(
+            self._sync(self._impl_obj.cookies(urls=mapping.to_impl(urls)))
+        )
+
+    def add_cookies(self, cookies: typing.Sequence[SetCookieParam]) -> None:
+        """BrowserContext.add_cookies
+
+        Adds cookies into this browser context. All pages within this context will have these cookies installed. Cookies
+        can be obtained via `browser_context.cookies()`.
+
+        **Usage**
+
+        ```py
+        browser_context.add_cookies([cookie_object1, cookie_object2])
+        ```
+
+        Parameters
+        ----------
+        cookies : Sequence[{name: str, value: str, url: Union[str, None], domain: Union[str, None], path: Union[str, None], expires: Union[float, None], httpOnly: Union[bool, None], secure: Union[bool, None], sameSite: Union["Lax", "None", "Strict", None], partitionKey: Union[str, None]}]
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.add_cookies(cookies=mapping.to_impl(cookies)))
+        )
+
+    def clear_cookies(
+        self,
+        *,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        domain: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        path: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> None:
+        """BrowserContext.clear_cookies
+
+        Removes cookies from context. Accepts optional filter.
+
+        **Usage**
+
+        ```py
+        context.clear_cookies()
+        context.clear_cookies(name=\"session-id\")
+        context.clear_cookies(domain=\"my-origin.com\")
+        context.clear_cookies(path=\"/api/v1\")
+        context.clear_cookies(name=\"session-id\", domain=\"my-origin.com\")
+        ```
+
+        Parameters
+        ----------
+        name : Union[Pattern[str], str, None]
+            Only removes cookies with the given name.
+        domain : Union[Pattern[str], str, None]
+            Only removes cookies with the given domain.
+        path : Union[Pattern[str], str, None]
+            Only removes cookies with the given path.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.clear_cookies(name=name, domain=domain, path=path)
+            )
+        )
+
+    def grant_permissions(
+        self, permissions: typing.Sequence[str], *, origin: typing.Optional[str] = None
+    ) -> None:
+        """BrowserContext.grant_permissions
+
+        Grants specified permissions to the browser context. Only grants corresponding permissions to the given origin if
+        specified.
+
+        Parameters
+        ----------
+        permissions : Sequence[str]
+            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'`
+            - `'local-fonts'`
+            - `'local-network-access'`
+            - `'magnetometer'`
+            - `'microphone'`
+            - `'midi-sysex'` (system-exclusive midi)
+            - `'midi'`
+            - `'notifications'`
+            - `'payment-handler'`
+            - `'storage-access'`
+            - `'screen-wake-lock'`
+        origin : Union[str, None]
+            The [origin] to grant permissions to, e.g. "https://example.com".
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.grant_permissions(
+                    permissions=mapping.to_impl(permissions), origin=origin
+                )
+            )
+        )
+
+    def clear_permissions(self) -> None:
+        """BrowserContext.clear_permissions
+
+        Clears all permission overrides for the browser context.
+
+        **Usage**
+
+        ```py
+        context = browser.new_context()
+        context.grant_permissions([\"clipboard-read\"])
+        # do stuff ..
+        context.clear_permissions()
+        ```
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.clear_permissions()))
+
+    def set_geolocation(self, geolocation: typing.Optional[Geolocation] = None) -> None:
+        """BrowserContext.set_geolocation
+
+        Sets the context's geolocation. Passing `null` or `undefined` emulates position unavailable.
+
+        **Usage**
+
+        ```py
+        browser_context.set_geolocation({\"latitude\": 59.95, \"longitude\": 30.31667})
+        ```
+
+        **NOTE** Consider using `browser_context.grant_permissions()` to grant permissions for the browser context
+        pages to read its geolocation.
+
+        Parameters
+        ----------
+        geolocation : Union[{latitude: float, longitude: float, accuracy: Union[float, None]}, None]
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.set_geolocation(geolocation=geolocation))
+        )
+
+    def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> None:
+        """BrowserContext.set_extra_http_headers
+
+        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.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** `browser_context.set_extra_http_headers()` does not guarantee the order of headers in the outgoing
+        requests.
+
+        Parameters
+        ----------
+        headers : Dict[str, str]
+            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_extra_http_headers(headers=mapping.to_impl(headers))
+            )
+        )
+
+    def set_offline(self, offline: bool) -> None:
+        """BrowserContext.set_offline
+
+        Parameters
+        ----------
+        offline : bool
+            Whether to emulate network being offline for the browser context.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.set_offline(offline=offline))
+        )
+
+    def add_init_script(
+        self,
+        script: typing.Optional[str] = None,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+    ) -> "SyncContextManager":
+        """BrowserContext.add_init_script
+
+        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:
+
+        ```py
+        # in your playwright script, assuming the preload.js file is in same directory.
+        browser_context.add_init_script(path=\"preload.js\")
+        ```
+
+        **NOTE** The order of evaluation of multiple scripts installed via `browser_context.add_init_script()` and
+        `page.add_init_script()` is not defined.
+
+        Parameters
+        ----------
+        script : Union[str, None]
+            Script to be evaluated in all pages in the browser context. Optional.
+        path : Union[pathlib.Path, str, None]
+            Path to the JavaScript file. If `path` is a relative path, then it is resolved relative to the current working
+            directory. Optional.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(self._impl_obj.add_init_script(script=script, path=path))
+        )
+
+    def expose_binding(
+        self, name: str, callback: typing.Callable
+    ) -> "SyncContextManager":
+        """BrowserContext.expose_binding
+
+        The method adds a function called `name` on the `window` object of every frame in every page in the context. When
+        called, the function executes `callback` and returns a [Promise] which resolves to the return value of `callback`.
+        If the `callback` returns a [Promise], it will be awaited.
+
+        The first argument of the `callback` function contains information about the caller: `{ browserContext:
+        BrowserContext, page: Page, frame: Frame }`.
+
+        See `page.expose_binding()` for page-only version.
+
+        **Usage**
+
+        An example of exposing page URL to all frames in all pages in the context:
+
+        ```py
+        from playwright.sync_api import sync_playwright, Playwright
+
+        def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = webkit.launch(headless=False)
+            context = browser.new_context()
+            context.expose_binding(\"pageURL\", lambda source: source[\"page\"].url)
+            page = context.new_page()
+            page.set_content(\"\"\"
+            <script>
+              async function onClick() {
+                document.querySelector('div').textContent = await window.pageURL();
+              }
+            </script>
+            <button onclick=\"onClick()\">Click me</button>
+            <div></div>
+            \"\"\")
+            page.get_by_role(\"button\").click()
+
+        with sync_playwright() as playwright:
+            run(playwright)
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Name of the function on the window object.
+        callback : Callable
+            Callback function that will be called in the Playwright's context.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.expose_binding(
+                    name=name, callback=self._wrap_handler(callback)
+                )
+            )
+        )
+
+    def expose_function(
+        self, name: str, callback: typing.Callable
+    ) -> "SyncContextManager":
+        """BrowserContext.expose_function
+
+        The method adds a function called `name` on the `window` object of every frame in every page in the context. When
+        called, the function executes `callback` and returns a [Promise] which resolves to the return value of `callback`.
+
+        If the `callback` returns a [Promise], it will be awaited.
+
+        See `page.expose_function()` for page-only version.
+
+        **Usage**
+
+        An example of adding a `sha256` function to all pages in the context:
+
+        ```py
+        import hashlib
+        from playwright.sync_api import sync_playwright
+
+        def sha256(text: str) -> str:
+            m = hashlib.sha256()
+            m.update(bytes(text, \"utf8\"))
+            return m.hexdigest()
+
+        def run(playwright: Playwright):
+            webkit = playwright.webkit
+            browser = webkit.launch(headless=False)
+            context = browser.new_context()
+            context.expose_function(\"sha256\", sha256)
+            page = context.new_page()
+            page.set_content(\"\"\"
+                <script>
+                  async function onClick() {
+                    document.querySelector('div').textContent = await window.sha256('PLAYWRIGHT');
+                  }
+                </script>
+                <button onclick=\"onClick()\">Click me</button>
+                <div></div>
+            \"\"\")
+            page.get_by_role(\"button\").click()
+
+        with sync_playwright() as playwright:
+            run(playwright)
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Name of the function on the window object.
+        callback : Callable
+            Callback function that will be called in the Playwright's context.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.expose_function(
+                    name=name, callback=self._wrap_handler(callback)
+                )
+            )
+        )
+
+    def route(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Union[
+            typing.Callable[["Route"], typing.Any],
+            typing.Callable[["Route", "Request"], typing.Any],
+        ],
+        *,
+        times: typing.Optional[int] = None,
+    ) -> "SyncContextManager":
+        """BrowserContext.route
+
+        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** `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` to `'block'`.
+
+        **Usage**
+
+        An example of a naive handler that aborts all image requests:
+
+        ```py
+        context = browser.new_context()
+        page = context.new_page()
+        context.route(\"**/*.{png,jpg,jpeg}\", lambda route: route.abort())
+        page.goto(\"https://example.com\")
+        browser.close()
+        ```
+
+        or the same snippet using a regex pattern instead:
+
+        ```py
+        context = browser.new_context()
+        page = context.new_page()
+        context.route(re.compile(r\"(\\.png$)|(\\.jpg$)\"), lambda route: route.abort())
+        page = await context.new_page()
+        page = context.new_page()
+        page.goto(\"https://example.com\")
+        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:
+
+        ```py
+        def handle_route(route: Route):
+          if (\"my-string\" in route.request.post_data):
+            route.fulfill(body=\"mocked-data\")
+          else:
+            route.continue_()
+        context.route(\"/api/**\", handle_route)
+        ```
+
+        Page routes (set up with `page.route()`) take precedence over browser context routes when request matches
+        both handlers.
+
+        To remove a route with its handler you can use `browser_context.unroute()`.
+
+        **NOTE** Enabling routing disables http cache.
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            A glob pattern, regex pattern, or predicate that receives a [URL] to match during routing. If `baseURL` is set in
+            the context options and the provided URL is a string that does not start with `*`, it is resolved using the
+            [`new URL()`](https://developer.mozilla.org/en-US/docs/Web/API/URL/URL) constructor.
+        handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
+            handler function to route the request.
+        times : Union[int, None]
+            How often a route should be used. By default it will be used every time.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.route(
+                    url=self._wrap_handler(url),
+                    handler=self._wrap_handler(handler),
+                    times=times,
+                )
+            )
+        )
+
+    def unroute(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Optional[
+            typing.Union[
+                typing.Callable[["Route"], typing.Any],
+                typing.Callable[["Route", "Request"], typing.Any],
+            ]
+        ] = None,
+    ) -> None:
+        """BrowserContext.unroute
+
+        Removes a route created with `browser_context.route()`. When `handler` is not specified, removes all routes
+        for the `url`.
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            A glob pattern, regex pattern, or predicate receiving [URL] used to register a routing with
+            `browser_context.route()`.
+        handler : Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
+            Optional handler function used to register a routing with `browser_context.route()`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.unroute(
+                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                )
+            )
+        )
+
+    def route_web_socket(
+        self,
+        url: typing.Union[str, typing.Pattern[str], typing.Callable[[str], bool]],
+        handler: typing.Callable[["WebSocketRoute"], typing.Any],
+    ) -> None:
+        """BrowserContext.route_web_socket
+
+        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` for more details
+        and examples.
+
+        ```py
+        def message_handler(ws: WebSocketRoute, message: Union[str, bytes]):
+          if message == \"to-be-blocked\":
+            return
+          ws.send(message)
+
+        def handler(ws: WebSocketRoute):
+          ws.route_send(lambda message: message_handler(ws, message))
+          ws.connect()
+
+        context.route_web_socket(\"/ws\", handler)
+        ```
+
+        Parameters
+        ----------
+        url : Union[Callable[[str], bool], Pattern[str], str]
+            Only WebSockets with the url matching this pattern will be routed. A string pattern can be relative to the
+            `baseURL` context option.
+        handler : Callable[[WebSocketRoute], Any]
+            Handler function to route the WebSocket.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.route_web_socket(
+                    url=self._wrap_handler(url), handler=self._wrap_handler(handler)
+                )
+            )
+        )
+
+    def unroute_all(
+        self,
+        *,
+        behavior: typing.Optional[Literal["default", "ignoreErrors", "wait"]] = None,
+    ) -> None:
+        """BrowserContext.unroute_all
+
+        Removes all routes created with `browser_context.route()` and `browser_context.route_from_har()`.
+
+        Parameters
+        ----------
+        behavior : Union["default", "ignoreErrors", "wait", None]
+            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
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.unroute_all(behavior=behavior))
+        )
+
+    def route_from_har(
+        self,
+        har: typing.Union[pathlib.Path, str],
+        *,
+        url: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        not_found: typing.Optional[Literal["abort", "fallback"]] = None,
+        update: typing.Optional[bool] = None,
+        update_content: typing.Optional[Literal["attach", "embed"]] = None,
+        update_mode: typing.Optional[Literal["full", "minimal"]] = None,
+    ) -> None:
+        """BrowserContext.route_from_har
+
+        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/python/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` to `'block'`.
+
+        Parameters
+        ----------
+        har : Union[pathlib.Path, str]
+            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.
+        url : Union[Pattern[str], str, None]
+            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.
+        not_found : Union["abort", "fallback", None]
+            - 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.
+        update : Union[bool, None]
+            If specified, updates the given HAR with the actual network information instead of serving from file. The file is
+            written to disk when `browser_context.close()` is called.
+        update_content : Union["attach", "embed", None]
+            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.
+        update_mode : Union["full", "minimal", None]
+            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`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.route_from_har(
+                    har=har,
+                    url=url,
+                    notFound=not_found,
+                    update=update,
+                    updateContent=update_content,
+                    updateMode=update_mode,
+                )
+            )
+        )
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["backgroundpage"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["BrowserContext"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["BrowserContext"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["ConsoleMessage"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Dialog"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Download"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Frame"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["page"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["pageclose"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["pageload"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Page"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["weberror"],
+        predicate: typing.Optional[typing.Callable[["WebError"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["WebError"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Request"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Response"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: typing.Literal["serviceworker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager["Worker"]: ...
+
+    @typing.overload
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> EventContextManager[typing.Any]: ...
+
+    def expect_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager:
+        """BrowserContext.expect_event
+
+        Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+        value. Will throw an error if the context closes before the event is fired. Returns the event data value.
+
+        **Usage**
+
+        ```py
+        with context.expect_event(\"page\") as event_info:
+            page.get_by_role(\"button\").click()
+        page = event_info.value
+        ```
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one would pass into `browserContext.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_event(
+                event=event,
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def is_closed(self) -> bool:
+        """BrowserContext.is_closed
+
+        Indicates that the browser context is in the process of closing or has already been closed.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.is_closed())
+
+    def close(self, *, reason: typing.Optional[str] = None) -> None:
+        """BrowserContext.close
+
+        Closes the browser context. All the pages that belong to the browser context will be closed.
+
+        **NOTE** The default browser context cannot be closed.
+
+        Parameters
+        ----------
+        reason : Union[str, None]
+            The reason to be reported to the operations interrupted by the context closure.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.close(reason=reason)))
+
+    def storage_state(
+        self,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        indexed_db: typing.Optional[bool] = None,
+    ) -> StorageState:
+        """BrowserContext.storage_state
+
+        Returns storage state for this browser context, contains current cookies, local storage snapshot and IndexedDB
+        snapshot.
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str, None]
+            The file path to save the storage state to. If `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.
+        indexed_db : Union[bool, None]
+            Set to `true` to include [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API) in the storage
+            state snapshot. If your application uses IndexedDB to store authentication tokens, like Firebase Authentication,
+            enable this.
+
+        Returns
+        -------
+        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
+        """
+
+        return mapping.from_impl(
+            self._sync(self._impl_obj.storage_state(path=path, indexedDB=indexed_db))
+        )
+
+    def set_storage_state(
+        self, storage_state: typing.Union[StorageState, str, pathlib.Path]
+    ) -> None:
+        """BrowserContext.set_storage_state
+
+        Clears the existing cookies, local storage and IndexedDB entries for all origins and sets the new storage state.
+
+        **Usage**
+
+        ```py
+        # Load storage state from a file and apply it to the context.
+        context.set_storage_state(\"state.json\")
+        ```
+
+        Parameters
+        ----------
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}]
+            Learn more about [storage state and auth](../auth.md).
+
+            Populates context with given storage state. This option can be used to initialize context with logged-in
+            information obtained via `browser_context.storage_state()`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.set_storage_state(storageState=storage_state))
+        )
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["backgroundpage"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["close"],
+        predicate: typing.Optional[typing.Callable[["BrowserContext"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "BrowserContext": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["console"],
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "ConsoleMessage": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["dialog"],
+        predicate: typing.Optional[typing.Callable[["Dialog"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Dialog": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["download"],
+        predicate: typing.Optional[typing.Callable[["Download"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Download": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["frameattached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["framedetached"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["framenavigated"],
+        predicate: typing.Optional[typing.Callable[["Frame"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Frame": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["page"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["pageclose"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["pageload"],
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Page": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["weberror"],
+        predicate: typing.Optional[typing.Callable[["WebError"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "WebError": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["request"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["requestfailed"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["requestfinished"],
+        predicate: typing.Optional[typing.Callable[["Request"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Request": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["response"],
+        predicate: typing.Optional[typing.Callable[["Response"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Response": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: typing.Literal["serviceworker"],
+        predicate: typing.Optional[typing.Callable[["Worker"], bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> "Worker": ...
+
+    @typing.overload
+    def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable[..., bool]] = None,
+        *,
+        timeout: typing.Optional[float] = None,
+    ) -> typing.Any: ...
+
+    def wait_for_event(
+        self,
+        event: str,
+        predicate: typing.Optional[typing.Callable] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Any:
+        """BrowserContext.wait_for_event
+
+        **NOTE** In most cases, you should use `browser_context.expect_event()`.
+
+        Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function
+        and waits for `predicate(event)` to return a truthy value. Will throw an error if the browser context is closed
+        before the `event` is fired.
+
+        Parameters
+        ----------
+        event : str
+            Event name, same one typically passed into `*.on(event)`.
+        predicate : Union[Callable, None]
+            Receives the event data and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for_event(
+                    event=event,
+                    predicate=self._wrap_handler(predicate),
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
+
+    def expect_console_message(
+        self,
+        predicate: typing.Optional[typing.Callable[["ConsoleMessage"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["ConsoleMessage"]:
+        """BrowserContext.expect_console_message
+
+        Performs action and waits for a `ConsoleMessage` to be logged by in the pages in the context. If predicate is
+        provided, it passes `ConsoleMessage` value into the `predicate` function and waits for `predicate(message)` to
+        return a truthy value. Will throw an error if the page is closed before the `browser_context.on('console')` event
+        is fired.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[ConsoleMessage], bool], None]
+            Receives the `ConsoleMessage` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[ConsoleMessage]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_console_message(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def expect_page(
+        self,
+        predicate: typing.Optional[typing.Callable[["Page"], bool]] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> EventContextManager["Page"]:
+        """BrowserContext.expect_page
+
+        Performs action and waits for a new `Page` to be created in the context. If predicate is provided, it passes `Page`
+        value into the `predicate` function and waits for `predicate(event)` to return a truthy value. Will throw an error
+        if the context closes before new `Page` is created.
+
+        Parameters
+        ----------
+        predicate : Union[Callable[[Page], bool], None]
+            Receives the `Page` object and resolves to truthy value when the waiting should resolve.
+        timeout : Union[float, None]
+            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 `browser_context.set_default_timeout()`.
+
+        Returns
+        -------
+        EventContextManager[Page]
+        """
+        return EventContextManager(
+            self,
+            self._impl_obj.expect_page(
+                predicate=self._wrap_handler(predicate),
+                timeout=to_milliseconds(timeout),
+            ).future,
+        )
+
+    def new_cdp_session(self, page: typing.Union["Page", "Frame"]) -> "CDPSession":
+        """BrowserContext.new_cdp_session
+
+        **NOTE** CDP sessions are only supported on Chromium-based browsers.
+
+        Returns the newly created session.
+
+        Parameters
+        ----------
+        page : Union[Frame, Page]
+            Target to create new session for. For backwards-compatibility, this parameter is named `page`, but it can be a
+            `Page` or `Frame` type.
+
+        Returns
+        -------
+        CDPSession
+        """
+
+        return mapping.from_impl(self._sync(self._impl_obj.new_cdp_session(page=page)))
+
+
+mapping.register(BrowserContextImpl, BrowserContext)
+
+
+class CDPSession(SyncBase):
+
+    @typing.overload
+    def on(
+        self, event: Literal["close"], f: typing.Callable[["CDPSession"], "None"]
+    ) -> None:
+        """
+        Emitted when the session is closed, either because the target was closed or `session.detach()` was called.
+        """
+
+    @typing.overload
+    def on(self, event: str, f: typing.Callable[..., None]) -> None: ...
+
+    def on(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self, event: Literal["close"], f: typing.Callable[["CDPSession"], "None"]
+    ) -> None:
+        """
+        Emitted when the session is closed, either because the target was closed or `session.detach()` was called.
+        """
+
+    @typing.overload
+    def once(self, event: str, f: typing.Callable[..., None]) -> None: ...
+
+    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().once(event=event, f=f)
+
+    def send(
+        self, method: str, params: typing.Optional[typing.Dict] = None
+    ) -> typing.Dict:
+        """CDPSession.send
+
+        Parameters
+        ----------
+        method : str
+            Protocol method name.
+        params : Union[Dict, None]
+            Optional method parameters.
+
+        Returns
+        -------
+        Dict
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.send(method=method, params=mapping.to_impl(params))
+            )
+        )
+
+    def detach(self) -> None:
+        """CDPSession.detach
+
+        Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be
+        used to send messages.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.detach()))
+
+
+mapping.register(CDPSessionImpl, CDPSession)
+
+
+class Browser(SyncContextManager):
+
+    @typing.overload
+    def on(
+        self, event: Literal["context"], f: typing.Callable[["BrowserContext"], "None"]
+    ) -> None:
+        """
+        Emitted when a new browser context is created."""
+
+    @typing.overload
+    def on(
+        self, event: Literal["disconnected"], f: typing.Callable[["Browser"], "None"]
+    ) -> None:
+        """
+        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()` method was called."""
+
+    def on(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().on(event=event, f=f)
+
+    @typing.overload
+    def once(
+        self, event: Literal["context"], f: typing.Callable[["BrowserContext"], "None"]
+    ) -> None:
+        """
+        Emitted when a new browser context is created."""
+
+    @typing.overload
+    def once(
+        self, event: Literal["disconnected"], f: typing.Callable[["Browser"], "None"]
+    ) -> None:
+        """
+        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()` method was called."""
+
+    def once(self, event: str, f: typing.Callable[..., None]) -> None:
+        return super().once(event=event, f=f)
+
+    @property
+    def contexts(self) -> typing.List["BrowserContext"]:
+        """Browser.contexts
+
+        Returns an array of all open browser contexts. In a newly created browser, this will return zero browser contexts.
+
+        **Usage**
+
+        ```py
+        browser = pw.webkit.launch()
+        print(len(browser.contexts)) # prints `0`
+        context = browser.new_context()
+        print(len(browser.contexts)) # prints `1`
+        ```
+
+        Returns
+        -------
+        List[BrowserContext]
+        """
+        return mapping.from_impl_list(self._impl_obj.contexts)
+
+    @property
+    def browser_type(self) -> "BrowserType":
+        """Browser.browser_type
+
+        Get the browser type (chromium, firefox or webkit) that the browser belongs to.
+
+        Returns
+        -------
+        BrowserType
+        """
+        return mapping.from_impl(self._impl_obj.browser_type)
+
+    @property
+    def version(self) -> str:
+        """Browser.version
+
+        Returns the browser version.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.version)
+
+    def is_connected(self) -> bool:
+        """Browser.is_connected
+
+        Indicates that the browser is connected.
+
+        Returns
+        -------
+        bool
+        """
+
+        return mapping.from_maybe_impl(self._impl_obj.is_connected())
+
+    def new_context(
+        self,
+        *,
+        viewport: typing.Optional[ViewportSize] = None,
+        screen: typing.Optional[ViewportSize] = None,
+        no_viewport: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        java_script_enabled: typing.Optional[bool] = None,
+        bypass_csp: typing.Optional[bool] = None,
+        user_agent: typing.Optional[str] = None,
+        locale: typing.Optional[str] = None,
+        timezone_id: typing.Optional[str] = None,
+        geolocation: typing.Optional[Geolocation] = None,
+        permissions: typing.Optional[typing.Sequence[str]] = None,
+        extra_http_headers: typing.Optional[typing.Dict[str, str]] = None,
+        offline: typing.Optional[bool] = None,
+        http_credentials: typing.Optional[HttpCredentials] = None,
+        device_scale_factor: typing.Optional[float] = None,
+        is_mobile: typing.Optional[bool] = None,
+        has_touch: typing.Optional[bool] = None,
+        color_scheme: typing.Optional[
+            Literal["dark", "light", "no-preference", "null"]
+        ] = None,
+        reduced_motion: typing.Optional[
+            Literal["no-preference", "null", "reduce"]
+        ] = None,
+        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
+        accept_downloads: typing.Optional[bool] = None,
+        default_browser_type: typing.Optional[str] = None,
+        proxy: typing.Optional[ProxySettings] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_har_omit_content: typing.Optional[bool] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_video_size: typing.Optional[ViewportSize] = None,
+        storage_state: typing.Optional[
+            typing.Union[StorageState, str, pathlib.Path]
+        ] = None,
+        base_url: typing.Optional[str] = None,
+        strict_selectors: typing.Optional[bool] = None,
+        service_workers: typing.Optional[Literal["allow", "block"]] = None,
+        record_har_url_filter: typing.Optional[
+            typing.Union[typing.Pattern[str], str]
+        ] = None,
+        record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+    ) -> "BrowserContext":
+        """Browser.new_context
+
+        Creates a new browser context. It won't share cookies/cache with other browser contexts.
+
+        **NOTE** If directly using this method to create `BrowserContext`s, it is best practice to explicitly close the
+        returned context via `browser_context.close()` when your code is done with the `BrowserContext`, and before
+        calling `browser.close()`. This will ensure the `context` is closed gracefully and any artifacts—like HARs
+        and videos—are fully flushed and saved.
+
+        **Usage**
+
+        ```py
+        browser = playwright.firefox.launch() # or \"chromium\" or \"webkit\".
+        # create a new incognito browser context.
+        context = browser.new_context()
+        # create a new page in a pristine context.
+        page = context.new_page()
+        page.goto(\"https://example.com\")
+
+        # gracefully close up everything
+        context.close()
+        browser.close()
+        ```
+
+        Parameters
+        ----------
+        viewport : Union[{width: int, height: int}, None]
+            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `no_viewport` disables the fixed
+            viewport. Learn more about [viewport emulation](../emulation.md#viewport).
+        screen : Union[{width: int, height: int}, None]
+            Emulates consistent window screen size available inside web page via `window.screen`. Is only used when the
+            `viewport` is set.
+        no_viewport : Union[bool, None]
+            Does not enforce fixed viewport, allows resizing window in the headed mode.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        java_script_enabled : Union[bool, None]
+            Whether or not to enable JavaScript in the context. Defaults to `true`. Learn more about
+            [disabling JavaScript](../emulation.md#javascript-enabled).
+        bypass_csp : Union[bool, None]
+            Toggles bypassing page's Content-Security-Policy. Defaults to `false`.
+        user_agent : Union[str, None]
+            Specific user agent to use in this context.
+        locale : Union[str, None]
+            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](../emulation.md#locale--timezone).
+        timezone_id : Union[str, None]
+            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.
+        geolocation : Union[{latitude: float, longitude: float, accuracy: Union[float, None]}, None]
+        permissions : Union[Sequence[str], None]
+            A list of permissions to grant to all pages in this context. See `browser_context.grant_permissions()` for
+            more details. Defaults to none.
+        extra_http_headers : Union[Dict[str, str], None]
+            An object containing additional HTTP headers to be sent with every request. Defaults to none.
+        offline : Union[bool, None]
+            Whether to emulate network being offline. Defaults to `false`. Learn more about
+            [network emulation](../emulation.md#offline).
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
+            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.
+        device_scale_factor : Union[float, None]
+            Specify device scale factor (can be thought of as dpr). Defaults to `1`. Learn more about
+            [emulating devices with device scale factor](../emulation.md#devices).
+        is_mobile : Union[bool, None]
+            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](../emulation.md#ismobile).
+        has_touch : Union[bool, None]
+            Specifies if viewport supports touch events. Defaults to false. Learn more about
+            [mobile emulation](../emulation.md#devices).
+        color_scheme : Union["dark", "light", "no-preference", "null", None]
+            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.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
+        reduced_motion : Union["no-preference", "null", "reduce", None]
+            Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        forced_colors : Union["active", "none", "null", None]
+            Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        accept_downloads : Union[bool, None]
+            Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.
+        proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
+            Network proxy settings to use with this context. Defaults to none.
+        record_har_path : Union[pathlib.Path, str, None]
+            Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into the specified HAR file
+            on the filesystem. If not specified, the HAR is not recorded. Make sure to call `browser_context.close()`
+            for the HAR to be saved.
+        record_har_omit_content : Union[bool, None]
+            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
+        record_video_dir : Union[pathlib.Path, str, None]
+            Enables video recording for all pages into the specified directory. If not specified videos are not recorded. Make
+            sure to call `browser_context.close()` for videos to be saved.
+        record_video_size : Union[{width: int, height: int}, None]
+            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.
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
+            Learn more about [storage state and auth](../auth.md).
+
+            Populates context with given storage state. This option can be used to initialize context with logged-in
+            information obtained via `browser_context.storage_state()`.
+        base_url : Union[str, None]
+            When using `page.goto()`, `page.route()`, `page.wait_for_url()`,
+            `page.expect_request()`, or `page.expect_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`
+        strict_selectors : Union[bool, None]
+            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` to learn
+            more about the strict mode.
+        service_workers : Union["allow", "block", None]
+            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.
+        record_har_url_filter : Union[Pattern[str], str, None]
+        record_har_mode : Union["full", "minimal", None]
+            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`.
+        record_har_content : Union["attach", "embed", "omit", None]
+            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 and all of these files are archived along with the
+            HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            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.
+
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
+
+            **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`.
+
+
+        Returns
+        -------
+        BrowserContext
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.new_context(
+                    viewport=viewport,
+                    screen=screen,
+                    noViewport=no_viewport,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    javaScriptEnabled=java_script_enabled,
+                    bypassCSP=bypass_csp,
+                    userAgent=user_agent,
+                    locale=locale,
+                    timezoneId=timezone_id,
+                    geolocation=geolocation,
+                    permissions=mapping.to_impl(permissions),
+                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                    offline=offline,
+                    httpCredentials=http_credentials,
+                    deviceScaleFactor=device_scale_factor,
+                    isMobile=is_mobile,
+                    hasTouch=has_touch,
+                    colorScheme=color_scheme,
+                    reducedMotion=reduced_motion,
+                    forcedColors=forced_colors,
+                    contrast=contrast,
+                    acceptDownloads=accept_downloads,
+                    defaultBrowserType=default_browser_type,
+                    proxy=proxy,
+                    recordHarPath=record_har_path,
+                    recordHarOmitContent=record_har_omit_content,
+                    recordVideoDir=record_video_dir,
+                    recordVideoSize=record_video_size,
+                    storageState=storage_state,
+                    baseURL=base_url,
+                    strictSelectors=strict_selectors,
+                    serviceWorkers=service_workers,
+                    recordHarUrlFilter=record_har_url_filter,
+                    recordHarMode=record_har_mode,
+                    recordHarContent=record_har_content,
+                    clientCertificates=client_certificates,
+                )
+            )
+        )
+
+    def new_page(
+        self,
+        *,
+        viewport: typing.Optional[ViewportSize] = None,
+        screen: typing.Optional[ViewportSize] = None,
+        no_viewport: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        java_script_enabled: typing.Optional[bool] = None,
+        bypass_csp: typing.Optional[bool] = None,
+        user_agent: typing.Optional[str] = None,
+        locale: typing.Optional[str] = None,
+        timezone_id: typing.Optional[str] = None,
+        geolocation: typing.Optional[Geolocation] = None,
+        permissions: typing.Optional[typing.Sequence[str]] = None,
+        extra_http_headers: typing.Optional[typing.Dict[str, str]] = None,
+        offline: typing.Optional[bool] = None,
+        http_credentials: typing.Optional[HttpCredentials] = None,
+        device_scale_factor: typing.Optional[float] = None,
+        is_mobile: typing.Optional[bool] = None,
+        has_touch: typing.Optional[bool] = None,
+        color_scheme: typing.Optional[
+            Literal["dark", "light", "no-preference", "null"]
+        ] = None,
+        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
+        reduced_motion: typing.Optional[
+            Literal["no-preference", "null", "reduce"]
+        ] = None,
+        accept_downloads: typing.Optional[bool] = None,
+        default_browser_type: typing.Optional[str] = None,
+        proxy: typing.Optional[ProxySettings] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_har_omit_content: typing.Optional[bool] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_video_size: typing.Optional[ViewportSize] = None,
+        storage_state: typing.Optional[
+            typing.Union[StorageState, str, pathlib.Path]
+        ] = None,
+        base_url: typing.Optional[str] = None,
+        strict_selectors: typing.Optional[bool] = None,
+        service_workers: typing.Optional[Literal["allow", "block"]] = None,
+        record_har_url_filter: typing.Optional[
+            typing.Union[typing.Pattern[str], str]
+        ] = None,
+        record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+    ) -> "Page":
+        """Browser.new_page
+
+        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.new_context()` followed by the
+        `browser_context.new_page()` to control their exact life times.
+
+        Parameters
+        ----------
+        viewport : Union[{width: int, height: int}, None]
+            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `no_viewport` disables the fixed
+            viewport. Learn more about [viewport emulation](../emulation.md#viewport).
+        screen : Union[{width: int, height: int}, None]
+            Emulates consistent window screen size available inside web page via `window.screen`. Is only used when the
+            `viewport` is set.
+        no_viewport : Union[bool, None]
+            Does not enforce fixed viewport, allows resizing window in the headed mode.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        java_script_enabled : Union[bool, None]
+            Whether or not to enable JavaScript in the context. Defaults to `true`. Learn more about
+            [disabling JavaScript](../emulation.md#javascript-enabled).
+        bypass_csp : Union[bool, None]
+            Toggles bypassing page's Content-Security-Policy. Defaults to `false`.
+        user_agent : Union[str, None]
+            Specific user agent to use in this context.
+        locale : Union[str, None]
+            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](../emulation.md#locale--timezone).
+        timezone_id : Union[str, None]
+            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.
+        geolocation : Union[{latitude: float, longitude: float, accuracy: Union[float, None]}, None]
+        permissions : Union[Sequence[str], None]
+            A list of permissions to grant to all pages in this context. See `browser_context.grant_permissions()` for
+            more details. Defaults to none.
+        extra_http_headers : Union[Dict[str, str], None]
+            An object containing additional HTTP headers to be sent with every request. Defaults to none.
+        offline : Union[bool, None]
+            Whether to emulate network being offline. Defaults to `false`. Learn more about
+            [network emulation](../emulation.md#offline).
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
+            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.
+        device_scale_factor : Union[float, None]
+            Specify device scale factor (can be thought of as dpr). Defaults to `1`. Learn more about
+            [emulating devices with device scale factor](../emulation.md#devices).
+        is_mobile : Union[bool, None]
+            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](../emulation.md#ismobile).
+        has_touch : Union[bool, None]
+            Specifies if viewport supports touch events. Defaults to false. Learn more about
+            [mobile emulation](../emulation.md#devices).
+        color_scheme : Union["dark", "light", "no-preference", "null", None]
+            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.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
+        forced_colors : Union["active", "none", "null", None]
+            Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        reduced_motion : Union["no-preference", "null", "reduce", None]
+            Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        accept_downloads : Union[bool, None]
+            Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.
+        proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
+            Network proxy settings to use with this context. Defaults to none.
+        record_har_path : Union[pathlib.Path, str, None]
+            Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into the specified HAR file
+            on the filesystem. If not specified, the HAR is not recorded. Make sure to call `browser_context.close()`
+            for the HAR to be saved.
+        record_har_omit_content : Union[bool, None]
+            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
+        record_video_dir : Union[pathlib.Path, str, None]
+            Enables video recording for all pages into the specified directory. If not specified videos are not recorded. Make
+            sure to call `browser_context.close()` for videos to be saved.
+        record_video_size : Union[{width: int, height: int}, None]
+            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.
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
+            Learn more about [storage state and auth](../auth.md).
+
+            Populates context with given storage state. This option can be used to initialize context with logged-in
+            information obtained via `browser_context.storage_state()`.
+        base_url : Union[str, None]
+            When using `page.goto()`, `page.route()`, `page.wait_for_url()`,
+            `page.expect_request()`, or `page.expect_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`
+        strict_selectors : Union[bool, None]
+            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` to learn
+            more about the strict mode.
+        service_workers : Union["allow", "block", None]
+            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.
+        record_har_url_filter : Union[Pattern[str], str, None]
+        record_har_mode : Union["full", "minimal", None]
+            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`.
+        record_har_content : Union["attach", "embed", "omit", None]
+            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 and all of these files are archived along with the
+            HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            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.
+
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
+
+            **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`.
+
+
+        Returns
+        -------
+        Page
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.new_page(
+                    viewport=viewport,
+                    screen=screen,
+                    noViewport=no_viewport,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    javaScriptEnabled=java_script_enabled,
+                    bypassCSP=bypass_csp,
+                    userAgent=user_agent,
+                    locale=locale,
+                    timezoneId=timezone_id,
+                    geolocation=geolocation,
+                    permissions=mapping.to_impl(permissions),
+                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                    offline=offline,
+                    httpCredentials=http_credentials,
+                    deviceScaleFactor=device_scale_factor,
+                    isMobile=is_mobile,
+                    hasTouch=has_touch,
+                    colorScheme=color_scheme,
+                    forcedColors=forced_colors,
+                    contrast=contrast,
+                    reducedMotion=reduced_motion,
+                    acceptDownloads=accept_downloads,
+                    defaultBrowserType=default_browser_type,
+                    proxy=proxy,
+                    recordHarPath=record_har_path,
+                    recordHarOmitContent=record_har_omit_content,
+                    recordVideoDir=record_video_dir,
+                    recordVideoSize=record_video_size,
+                    storageState=storage_state,
+                    baseURL=base_url,
+                    strictSelectors=strict_selectors,
+                    serviceWorkers=service_workers,
+                    recordHarUrlFilter=record_har_url_filter,
+                    recordHarMode=record_har_mode,
+                    recordHarContent=record_har_content,
+                    clientCertificates=client_certificates,
+                )
+            )
+        )
+
+    def close(self, *, reason: typing.Optional[str] = None) -> None:
+        """Browser.close
+
+        In case this browser is obtained using `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 `browser_context.close()` on any `BrowserContext` instances you explicitly created earlier
+        using `browser.new_context()` **before** calling `browser.close()`.
+
+        The `Browser` object itself is considered to be disposed and cannot be used anymore.
+
+        Parameters
+        ----------
+        reason : Union[str, None]
+            The reason to be reported to the operations interrupted by the browser closure.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.close(reason=reason)))
+
+    def new_browser_cdp_session(self) -> "CDPSession":
+        """Browser.new_browser_cdp_session
+
+        **NOTE** CDP Sessions are only supported on Chromium-based browsers.
+
+        Returns the newly created browser session.
+
+        Returns
+        -------
+        CDPSession
+        """
+
+        return mapping.from_impl(self._sync(self._impl_obj.new_browser_cdp_session()))
+
+    def bind(
+        self,
+        title: str,
+        *,
+        workspace_dir: typing.Optional[str] = None,
+        host: typing.Optional[str] = None,
+        port: typing.Optional[int] = None,
+    ) -> BrowserBindResult:
+        """Browser.bind
+
+        Binds the browser to a named pipe or web socket, making it available for other clients to connect to.
+
+        Parameters
+        ----------
+        title : str
+            Title of the browser server, used for identification.
+        workspace_dir : Union[str, None]
+            Working directory associated with this browser server.
+        host : Union[str, None]
+            Host to bind the web socket server to. When specified, a web socket server is created instead of a named pipe.
+        port : Union[int, None]
+            Port to bind the web socket server to. When specified, a web socket server is created instead of a named pipe. Use
+            `0` to let the OS pick an available port.
+
+        Returns
+        -------
+        {endpoint: str}
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.bind(
+                    title=title, workspaceDir=workspace_dir, host=host, port=port
+                )
+            )
+        )
+
+    def unbind(self) -> None:
+        """Browser.unbind
+
+        Unbinds the browser server previously bound with `browser.bind()`.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.unbind()))
+
+    def start_tracing(
+        self,
+        *,
+        page: typing.Optional["Page"] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        screenshots: typing.Optional[bool] = None,
+        categories: typing.Optional[typing.Sequence[str]] = None,
+    ) -> None:
+        """Browser.start_tracing
+
+        **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/python/docs/trace-viewer) could be found
+        [here](https://playwright.dev/python/docs/api/class-tracing).
+
+        You can use `browser.start_tracing()` and `browser.stop_tracing()` to create a trace file that can be
+        opened in Chrome DevTools performance panel.
+
+        **Usage**
+
+        ```py
+        browser.start_tracing(page, path=\"trace.json\")
+        page.goto(\"https://www.google.com\")
+        browser.stop_tracing()
+        ```
+
+        Parameters
+        ----------
+        page : Union[Page, None]
+            Optional, if specified, tracing includes screenshots of the given page.
+        path : Union[pathlib.Path, str, None]
+            A path to write the trace file to.
+        screenshots : Union[bool, None]
+            captures screenshots in the trace.
+        categories : Union[Sequence[str], None]
+            specify custom categories to use instead of default.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.start_tracing(
+                    page=page._impl_obj if page else None,
+                    path=path,
+                    screenshots=screenshots,
+                    categories=mapping.to_impl(categories),
+                )
+            )
+        )
+
+    def stop_tracing(self) -> bytes:
+        """Browser.stop_tracing
+
+        **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/python/docs/trace-viewer) could be found
+        [here](https://playwright.dev/python/docs/api/class-tracing).
+
+        Returns the buffer with trace data.
+
+        Returns
+        -------
+        bytes
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.stop_tracing()))
+
+
+mapping.register(BrowserImpl, Browser)
+
+
+class BrowserType(SyncBase):
+
+    @property
+    def name(self) -> str:
+        """BrowserType.name
+
+        Returns browser name. For example: `'chromium'`, `'webkit'` or `'firefox'`.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.name)
+
+    @property
+    def executable_path(self) -> str:
+        """BrowserType.executable_path
+
+        A path where Playwright expects to find a bundled browser executable.
+
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.executable_path)
+
+    def launch(
+        self,
+        *,
+        executable_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        channel: typing.Optional[str] = None,
+        args: typing.Optional[typing.Sequence[str]] = None,
+        ignore_default_args: typing.Optional[
+            typing.Union[bool, typing.Sequence[str]]
+        ] = None,
+        handle_sigint: typing.Optional[bool] = None,
+        handle_sigterm: typing.Optional[bool] = None,
+        handle_sighup: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        env: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
+        headless: typing.Optional[bool] = None,
+        proxy: typing.Optional[ProxySettings] = None,
+        downloads_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        slow_mo: typing.Optional[float] = None,
+        traces_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        artifacts_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        chromium_sandbox: typing.Optional[bool] = None,
+        firefox_user_prefs: typing.Optional[
+            typing.Dict[str, typing.Union[str, float, bool]]
+        ] = None,
+    ) -> "Browser":
+        """BrowserType.launch
+
+        Returns the browser instance.
+
+        **Usage**
+
+        You can use `ignoreDefaultArgs` to filter out `--mute-audio` from default arguments:
+
+        ```py
+        browser = playwright.chromium.launch( # or \"firefox\" or \"webkit\".
+            ignore_default_args=[\"--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` 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.
+
+        Parameters
+        ----------
+        executable_path : Union[pathlib.Path, str, None]
+            Path to a browser executable to run instead of the bundled one. If `executablePath` 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.
+        channel : Union[str, None]
+            Browser distribution channel.
+
+            Use "chromium" to [opt in to new headless mode](../browsers.md#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](../browsers.md#google-chrome--microsoft-edge).
+        args : Union[Sequence[str], None]
+            **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/).
+        ignore_default_args : Union[Sequence[str], bool, None]
+            If `true`, Playwright does not pass its own configurations args and only uses the ones from `args`. If an array is
+            given, then filters out the given default arguments. Dangerous option; use with care. Defaults to `false`.
+        handle_sigint : Union[bool, None]
+            Close the browser process on Ctrl-C. Defaults to `true`.
+        handle_sigterm : Union[bool, None]
+            Close the browser process on SIGTERM. Defaults to `true`.
+        handle_sighup : Union[bool, None]
+            Close the browser process on SIGHUP. Defaults to `true`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the browser instance to start. Defaults to `30000` (30 seconds). Pass `0`
+            to disable timeout.
+        env : Union[Dict[str, Union[bool, float, str]], None]
+            Specify environment variables that will be visible to the browser. Defaults to `process.env`.
+        headless : Union[bool, None]
+            Whether to run browser in headless mode. More details for
+            [Chromium](https://developers.google.com/web/updates/2017/04/headless-chrome) and
+            [Firefox](https://hacks.mozilla.org/2017/12/using-headless-mode-in-firefox/). Defaults to `true`.
+        proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
+            Network proxy settings.
+        downloads_path : Union[pathlib.Path, str, None]
+            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.
+        slow_mo : Union[float, None]
+            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going
+            on.
+        traces_dir : Union[pathlib.Path, str, None]
+            If specified, traces are saved into this directory.
+        artifacts_dir : Union[pathlib.Path, str, None]
+            If specified, artifacts (traces, videos, downloads, HAR files, etc.) are saved into this directory. The directory
+            is not cleaned up when the browser closes. If not specified, a temporary directory is used and cleaned up when the
+            browser closes.
+        chromium_sandbox : Union[bool, None]
+            Enable Chromium sandboxing. Defaults to `false`.
+        firefox_user_prefs : Union[Dict[str, Union[bool, float, str]], None]
+            Firefox user preferences. Learn more about the Firefox user preferences at
+            [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox).
+
+            You can also provide a path to a custom [`policies.json` file](https://mozilla.github.io/policy-templates/) via
+            `PLAYWRIGHT_FIREFOX_POLICIES_JSON` environment variable.
+
+        Returns
+        -------
+        Browser
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.launch(
+                    executablePath=executable_path,
+                    channel=channel,
+                    args=mapping.to_impl(args),
+                    ignoreDefaultArgs=mapping.to_impl(ignore_default_args),
+                    handleSIGINT=handle_sigint,
+                    handleSIGTERM=handle_sigterm,
+                    handleSIGHUP=handle_sighup,
+                    timeout=to_milliseconds(timeout),
+                    env=mapping.to_impl(env),
+                    headless=headless,
+                    proxy=proxy,
+                    downloadsPath=downloads_path,
+                    slowMo=slow_mo,
+                    tracesDir=traces_dir,
+                    artifactsDir=artifacts_dir,
+                    chromiumSandbox=chromium_sandbox,
+                    firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
+                )
+            )
+        )
+
+    def launch_persistent_context(
+        self,
+        user_data_dir: typing.Union[str, pathlib.Path],
+        *,
+        channel: typing.Optional[str] = None,
+        executable_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        args: typing.Optional[typing.Sequence[str]] = None,
+        ignore_default_args: typing.Optional[
+            typing.Union[bool, typing.Sequence[str]]
+        ] = None,
+        handle_sigint: typing.Optional[bool] = None,
+        handle_sigterm: typing.Optional[bool] = None,
+        handle_sighup: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        env: typing.Optional[typing.Dict[str, typing.Union[str, float, bool]]] = None,
+        headless: typing.Optional[bool] = None,
+        proxy: typing.Optional[ProxySettings] = None,
+        downloads_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        slow_mo: typing.Optional[float] = None,
+        viewport: typing.Optional[ViewportSize] = None,
+        screen: typing.Optional[ViewportSize] = None,
+        no_viewport: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        java_script_enabled: typing.Optional[bool] = None,
+        bypass_csp: typing.Optional[bool] = None,
+        user_agent: typing.Optional[str] = None,
+        locale: typing.Optional[str] = None,
+        timezone_id: typing.Optional[str] = None,
+        geolocation: typing.Optional[Geolocation] = None,
+        permissions: typing.Optional[typing.Sequence[str]] = None,
+        extra_http_headers: typing.Optional[typing.Dict[str, str]] = None,
+        offline: typing.Optional[bool] = None,
+        http_credentials: typing.Optional[HttpCredentials] = None,
+        device_scale_factor: typing.Optional[float] = None,
+        is_mobile: typing.Optional[bool] = None,
+        has_touch: typing.Optional[bool] = None,
+        color_scheme: typing.Optional[
+            Literal["dark", "light", "no-preference", "null"]
+        ] = None,
+        reduced_motion: typing.Optional[
+            Literal["no-preference", "null", "reduce"]
+        ] = None,
+        forced_colors: typing.Optional[Literal["active", "none", "null"]] = None,
+        contrast: typing.Optional[Literal["more", "no-preference", "null"]] = None,
+        accept_downloads: typing.Optional[bool] = None,
+        traces_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        artifacts_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        chromium_sandbox: typing.Optional[bool] = None,
+        firefox_user_prefs: typing.Optional[
+            typing.Dict[str, typing.Union[str, float, bool]]
+        ] = None,
+        record_har_path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_har_omit_content: typing.Optional[bool] = None,
+        record_video_dir: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        record_video_size: typing.Optional[ViewportSize] = None,
+        base_url: typing.Optional[str] = None,
+        strict_selectors: typing.Optional[bool] = None,
+        service_workers: typing.Optional[Literal["allow", "block"]] = None,
+        record_har_url_filter: typing.Optional[
+            typing.Union[typing.Pattern[str], str]
+        ] = None,
+        record_har_mode: typing.Optional[Literal["full", "minimal"]] = None,
+        record_har_content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+    ) -> "BrowserContext":
+        """BrowserType.launch_persistent_context
+
+        Returns the persistent browser context instance.
+
+        Launches browser that uses persistent storage located at `userDataDir` and returns the only context. Closing this
+        context will automatically close the browser.
+
+        Parameters
+        ----------
+        user_data_dir : Union[pathlib.Path, str]
+            Path to a User Data Directory, which stores browser session data like cookies and local storage. Pass an empty
+            string to create a temporary directory.
+
+            More details for
+            [Chromium](https://chromium.googlesource.com/chromium/src/+/master/docs/user_data_dir.md#introduction) and
+            [Firefox](https://wiki.mozilla.org/Firefox/CommandLineOptions#User_profile). Chromium's user data directory is the
+            **parent** directory of the "Profile Path" seen at `chrome://version`.
+
+            Note that browsers do not allow launching multiple instances with the same User Data Directory.
+
+            **NOTE** Chromium/Chrome: Due to recent Chrome policy changes, automating the default Chrome user profile is not
+            supported. Pointing `userDataDir` to Chrome's main "User Data" directory (the profile used for your regular
+            browsing) may result in pages not loading or the browser exiting. Create and use a separate directory (for example,
+            an empty folder) as your automation profile instead. See https://developer.chrome.com/blog/remote-debugging-port
+            for details.
+
+        channel : Union[str, None]
+            Browser distribution channel.
+
+            Use "chromium" to [opt in to new headless mode](../browsers.md#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](../browsers.md#google-chrome--microsoft-edge).
+        executable_path : Union[pathlib.Path, str, None]
+            Path to a browser executable to run instead of the bundled one. If `executablePath` 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.
+        args : Union[Sequence[str], None]
+            **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/).
+        ignore_default_args : Union[Sequence[str], bool, None]
+            If `true`, Playwright does not pass its own configurations args and only uses the ones from `args`. If an array is
+            given, then filters out the given default arguments. Dangerous option; use with care. Defaults to `false`.
+        handle_sigint : Union[bool, None]
+            Close the browser process on Ctrl-C. Defaults to `true`.
+        handle_sigterm : Union[bool, None]
+            Close the browser process on SIGTERM. Defaults to `true`.
+        handle_sighup : Union[bool, None]
+            Close the browser process on SIGHUP. Defaults to `true`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the browser instance to start. Defaults to `30000` (30 seconds). Pass `0`
+            to disable timeout.
+        env : Union[Dict[str, Union[bool, float, str]], None]
+            Specify environment variables that will be visible to the browser. Defaults to `process.env`.
+        headless : Union[bool, None]
+            Whether to run browser in headless mode. More details for
+            [Chromium](https://developers.google.com/web/updates/2017/04/headless-chrome) and
+            [Firefox](https://hacks.mozilla.org/2017/12/using-headless-mode-in-firefox/). Defaults to `true`.
+        proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
+            Network proxy settings.
+        downloads_path : Union[pathlib.Path, str, None]
+            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.
+        slow_mo : Union[float, None]
+            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going
+            on.
+        viewport : Union[{width: int, height: int}, None]
+            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `no_viewport` disables the fixed
+            viewport. Learn more about [viewport emulation](../emulation.md#viewport).
+        screen : Union[{width: int, height: int}, None]
+            Emulates consistent window screen size available inside web page via `window.screen`. Is only used when the
+            `viewport` is set.
+        no_viewport : Union[bool, None]
+            Does not enforce fixed viewport, allows resizing window in the headed mode.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        java_script_enabled : Union[bool, None]
+            Whether or not to enable JavaScript in the context. Defaults to `true`. Learn more about
+            [disabling JavaScript](../emulation.md#javascript-enabled).
+        bypass_csp : Union[bool, None]
+            Toggles bypassing page's Content-Security-Policy. Defaults to `false`.
+        user_agent : Union[str, None]
+            Specific user agent to use in this context.
+        locale : Union[str, None]
+            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](../emulation.md#locale--timezone).
+        timezone_id : Union[str, None]
+            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.
+        geolocation : Union[{latitude: float, longitude: float, accuracy: Union[float, None]}, None]
+        permissions : Union[Sequence[str], None]
+            A list of permissions to grant to all pages in this context. See `browser_context.grant_permissions()` for
+            more details. Defaults to none.
+        extra_http_headers : Union[Dict[str, str], None]
+            An object containing additional HTTP headers to be sent with every request. Defaults to none.
+        offline : Union[bool, None]
+            Whether to emulate network being offline. Defaults to `false`. Learn more about
+            [network emulation](../emulation.md#offline).
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
+            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.
+        device_scale_factor : Union[float, None]
+            Specify device scale factor (can be thought of as dpr). Defaults to `1`. Learn more about
+            [emulating devices with device scale factor](../emulation.md#devices).
+        is_mobile : Union[bool, None]
+            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](../emulation.md#ismobile).
+        has_touch : Union[bool, None]
+            Specifies if viewport supports touch events. Defaults to false. Learn more about
+            [mobile emulation](../emulation.md#devices).
+        color_scheme : Union["dark", "light", "no-preference", "null", None]
+            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.emulate_media()` for more details.
+            Passing `'null'` resets emulation to system defaults. Defaults to `'light'`.
+        reduced_motion : Union["no-preference", "null", "reduce", None]
+            Emulates `'prefers-reduced-motion'` media feature, supported values are `'reduce'`, `'no-preference'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        forced_colors : Union["active", "none", "null", None]
+            Emulates `'forced-colors'` media feature, supported values are `'active'`, `'none'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'none'`.
+        contrast : Union["more", "no-preference", "null", None]
+            Emulates `'prefers-contrast'` media feature, supported values are `'no-preference'`, `'more'`. See
+            `page.emulate_media()` for more details. Passing `'null'` resets emulation to system defaults. Defaults to
+            `'no-preference'`.
+        accept_downloads : Union[bool, None]
+            Whether to automatically download all the attachments. Defaults to `true` where all the downloads are accepted.
+        traces_dir : Union[pathlib.Path, str, None]
+            If specified, traces are saved into this directory.
+        artifacts_dir : Union[pathlib.Path, str, None]
+            If specified, artifacts (traces, videos, downloads, HAR files, etc.) are saved into this directory. The directory
+            is not cleaned up when the browser closes. If not specified, a temporary directory is used and cleaned up when the
+            browser closes.
+        chromium_sandbox : Union[bool, None]
+            Enable Chromium sandboxing. Defaults to `false`.
+        firefox_user_prefs : Union[Dict[str, Union[bool, float, str]], None]
+            Firefox user preferences. Learn more about the Firefox user preferences at
+            [`about:config`](https://support.mozilla.org/en-US/kb/about-config-editor-firefox).
+
+            You can also provide a path to a custom [`policies.json` file](https://mozilla.github.io/policy-templates/) via
+            `PLAYWRIGHT_FIREFOX_POLICIES_JSON` environment variable.
+        record_har_path : Union[pathlib.Path, str, None]
+            Enables [HAR](http://www.softwareishard.com/blog/har-12-spec) recording for all pages into the specified HAR file
+            on the filesystem. If not specified, the HAR is not recorded. Make sure to call `browser_context.close()`
+            for the HAR to be saved.
+        record_har_omit_content : Union[bool, None]
+            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
+        record_video_dir : Union[pathlib.Path, str, None]
+            Enables video recording for all pages into the specified directory. If not specified videos are not recorded. Make
+            sure to call `browser_context.close()` for videos to be saved.
+        record_video_size : Union[{width: int, height: int}, None]
+            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.
+        base_url : Union[str, None]
+            When using `page.goto()`, `page.route()`, `page.wait_for_url()`,
+            `page.expect_request()`, or `page.expect_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`
+        strict_selectors : Union[bool, None]
+            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` to learn
+            more about the strict mode.
+        service_workers : Union["allow", "block", None]
+            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.
+        record_har_url_filter : Union[Pattern[str], str, None]
+        record_har_mode : Union["full", "minimal", None]
+            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`.
+        record_har_content : Union["attach", "embed", "omit", None]
+            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 and all of these files are archived along with the
+            HAR file. Defaults to `embed`, which stores content inline the HAR file as per HAR specification.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            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.
+
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
+
+            **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`.
+
+
+        Returns
+        -------
+        BrowserContext
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.launch_persistent_context(
+                    userDataDir=user_data_dir,
+                    channel=channel,
+                    executablePath=executable_path,
+                    args=mapping.to_impl(args),
+                    ignoreDefaultArgs=mapping.to_impl(ignore_default_args),
+                    handleSIGINT=handle_sigint,
+                    handleSIGTERM=handle_sigterm,
+                    handleSIGHUP=handle_sighup,
+                    timeout=to_milliseconds(timeout),
+                    env=mapping.to_impl(env),
+                    headless=headless,
+                    proxy=proxy,
+                    downloadsPath=downloads_path,
+                    slowMo=slow_mo,
+                    viewport=viewport,
+                    screen=screen,
+                    noViewport=no_viewport,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    javaScriptEnabled=java_script_enabled,
+                    bypassCSP=bypass_csp,
+                    userAgent=user_agent,
+                    locale=locale,
+                    timezoneId=timezone_id,
+                    geolocation=geolocation,
+                    permissions=mapping.to_impl(permissions),
+                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                    offline=offline,
+                    httpCredentials=http_credentials,
+                    deviceScaleFactor=device_scale_factor,
+                    isMobile=is_mobile,
+                    hasTouch=has_touch,
+                    colorScheme=color_scheme,
+                    reducedMotion=reduced_motion,
+                    forcedColors=forced_colors,
+                    contrast=contrast,
+                    acceptDownloads=accept_downloads,
+                    tracesDir=traces_dir,
+                    artifactsDir=artifacts_dir,
+                    chromiumSandbox=chromium_sandbox,
+                    firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
+                    recordHarPath=record_har_path,
+                    recordHarOmitContent=record_har_omit_content,
+                    recordVideoDir=record_video_dir,
+                    recordVideoSize=record_video_size,
+                    baseURL=base_url,
+                    strictSelectors=strict_selectors,
+                    serviceWorkers=service_workers,
+                    recordHarUrlFilter=record_har_url_filter,
+                    recordHarMode=record_har_mode,
+                    recordHarContent=record_har_content,
+                    clientCertificates=client_certificates,
+                )
+            )
+        )
+
+    def connect_over_cdp(
+        self,
+        endpoint_url: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        slow_mo: typing.Optional[float] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        is_local: typing.Optional[bool] = None,
+        no_defaults: typing.Optional[bool] = None,
+    ) -> "Browser":
+        """BrowserType.connect_over_cdp
+
+        This method attaches Playwright to an existing browser instance using the Chrome DevTools Protocol.
+
+        The default browser context is accessible via `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
+        `browser_type.connect()`. If you are experiencing issues or attempting to use advanced functionality, you
+        probably want to use `browser_type.connect()`.
+
+        **Usage**
+
+        ```py
+        browser = playwright.chromium.connect_over_cdp(\"http://localhost:9222\")
+        default_context = browser.contexts[0]
+        page = default_context.pages[0]
+        ```
+
+        Parameters
+        ----------
+        endpoint_url : str
+            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`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the connection to be established. Defaults to `30000` (30 seconds). Pass
+            `0` to disable timeout.
+        slow_mo : Union[float, None]
+            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going
+            on. Defaults to 0.
+        headers : Union[Dict[str, str], None]
+            Additional HTTP headers to be sent with connect request. Optional.
+        is_local : Union[bool, None]
+            Tells Playwright that it runs on the same host as the CDP server. It will enable certain optimizations that rely
+            upon the file system being the same between Playwright and the Browser.
+        no_defaults : Union[bool, None]
+            When true, Playwright will not apply its default overrides to the existing default browser context. Specifically,
+            `acceptDownloads` is left at the browser's setting, focus emulation is not enabled, and media emulation options
+            (such as `colorScheme`, `reducedMotion`, `forcedColors`, and `contrast`) are not applied. Useful when attaching to
+            a user's daily-driver browser where these overrides would interfere with existing browser state. New contexts
+            created via `browser.new_context()` are not affected. Defaults to `false`.
+
+        Returns
+        -------
+        Browser
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.connect_over_cdp(
+                    endpointURL=endpoint_url,
+                    timeout=to_milliseconds(timeout),
+                    slowMo=slow_mo,
+                    headers=mapping.to_impl(headers),
+                    isLocal=is_local,
+                    noDefaults=no_defaults,
+                )
+            )
+        )
+
+    def connect(
+        self,
+        endpoint: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        slow_mo: typing.Optional[float] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        expose_network: typing.Optional[str] = None,
+    ) -> "Browser":
+        """BrowserType.connect
+
+        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).
+
+        Parameters
+        ----------
+        endpoint : str
+            A Playwright browser websocket endpoint to connect to. You obtain this endpoint via `BrowserServer.wsEndpoint`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the connection to be established. Defaults to `0` (no timeout).
+        slow_mo : Union[float, None]
+            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going
+            on. Defaults to 0.
+        headers : Union[Dict[str, str], None]
+            Additional HTTP headers to be sent with web socket connect request. Optional.
+        expose_network : Union[str, None]
+            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.
+
+        Returns
+        -------
+        Browser
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.connect(
+                    endpoint=endpoint,
+                    timeout=to_milliseconds(timeout),
+                    slowMo=slow_mo,
+                    headers=mapping.to_impl(headers),
+                    exposeNetwork=expose_network,
+                )
+            )
+        )
+
+
+mapping.register(BrowserTypeImpl, BrowserType)
+
+
+class Playwright(SyncBase):
+
+    @property
+    def devices(self) -> typing.Dict:
+        """Playwright.devices
+
+        Returns a dictionary of devices to be used with `browser.new_context()` or `browser.new_page()`.
+
+        ```py
+        from playwright.sync_api import sync_playwright, Playwright
+
+        def run(playwright: Playwright):
+            webkit = playwright.webkit
+            iphone = playwright.devices[\"iPhone 6\"]
+            browser = webkit.launch()
+            context = browser.new_context(**iphone)
+            page = context.new_page()
+            page.goto(\"http://example.com\")
+            # other actions...
+            browser.close()
+
+        with sync_playwright() as playwright:
+            run(playwright)
+        ```
+
+        Returns
+        -------
+        Dict
+        """
+        return mapping.from_maybe_impl(self._impl_obj.devices)
+
+    @property
+    def selectors(self) -> "Selectors":
+        """Playwright.selectors
+
+        Selectors can be used to install custom selector engines. See [extensibility](https://playwright.dev/python/docs/extensibility) for more
+        information.
+
+        Returns
+        -------
+        Selectors
+        """
+        return mapping.from_impl(self._impl_obj.selectors)
+
+    @property
+    def chromium(self) -> "BrowserType":
+        """Playwright.chromium
+
+        This object can be used to launch or connect to Chromium, returning instances of `Browser`.
+
+        Returns
+        -------
+        BrowserType
+        """
+        return mapping.from_impl(self._impl_obj.chromium)
+
+    @property
+    def firefox(self) -> "BrowserType":
+        """Playwright.firefox
+
+        This object can be used to launch or connect to Firefox, returning instances of `Browser`.
+
+        Returns
+        -------
+        BrowserType
+        """
+        return mapping.from_impl(self._impl_obj.firefox)
+
+    @property
+    def webkit(self) -> "BrowserType":
+        """Playwright.webkit
+
+        This object can be used to launch or connect to WebKit, returning instances of `Browser`.
+
+        Returns
+        -------
+        BrowserType
+        """
+        return mapping.from_impl(self._impl_obj.webkit)
+
+    @property
+    def request(self) -> "APIRequest":
+        """Playwright.request
+
+        Exposes API that can be used for the Web API testing.
+
+        Returns
+        -------
+        APIRequest
+        """
+        return mapping.from_impl(self._impl_obj.request)
+
+    def __getitem__(self, value: str) -> "BrowserType":
+
+        return mapping.from_impl(self._impl_obj.__getitem__(value=value))
+
+    def stop(self) -> None:
+        """Playwright.stop
+
+        Terminates this instance of Playwright in case it was created bypassing the Python context manager. This is useful
+        in REPL applications.
+
+        ```py
+        from playwright.sync_api import sync_playwright
+
+        playwright = sync_playwright().start()
+
+        browser = playwright.chromium.launch()
+        page = browser.new_page()
+        page.goto(\"https://playwright.dev/\")
+        page.screenshot(path=\"example.png\")
+        browser.close()
+
+        playwright.stop()
+        ```
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.stop()))
+
+
+mapping.register(PlaywrightImpl, Playwright)
+
+
+class Tracing(SyncBase):
+
+    def start(
+        self,
+        *,
+        name: typing.Optional[str] = None,
+        title: typing.Optional[str] = None,
+        snapshots: typing.Optional[bool] = None,
+        screenshots: typing.Optional[bool] = None,
+        sources: typing.Optional[bool] = None,
+        live: typing.Optional[bool] = None,
+    ) -> None:
+        """Tracing.start
+
+        Start tracing.
+
+        **NOTE** You probably want to
+        [enable tracing in your config file](https://playwright.dev/docs/api/class-testoptions#test-options-trace) instead
+        of using `Tracing.start`.
+
+        The `context.tracing` API captures browser operations and network activity, but it doesn't record test assertions
+        (like `expect` calls). We recommend
+        [enabling tracing through Playwright Test configuration](https://playwright.dev/docs/api/class-testoptions#test-options-trace),
+        which includes those assertions and provides a more complete trace for debugging test failures.
+
+        **Usage**
+
+        ```py
+        context.tracing.start(screenshots=True, snapshots=True)
+        page = context.new_page()
+        page.goto(\"https://playwright.dev\")
+        context.tracing.stop(path = \"trace.zip\")
+        ```
+
+        Parameters
+        ----------
+        name : Union[str, None]
+            If specified, intermediate trace files are going to be saved into the files with the given name prefix inside the
+            `tracesDir` directory specified in `browser_type.launch()`. To specify the final trace zip file name, you
+            need to pass `path` option to `tracing.stop()` instead.
+        title : Union[str, None]
+            Trace name to be shown in the Trace Viewer.
+        snapshots : Union[bool, None]
+            If this option is true tracing will
+            - capture DOM snapshot on every action
+            - record network activity
+        screenshots : Union[bool, None]
+            Whether to capture screenshots during tracing. Screenshots are used to build a timeline preview.
+        sources : Union[bool, None]
+            Whether to include source files for trace actions.
+        live : Union[bool, None]
+            When enabled, the trace is written to an unarchived file that is updated in real time as actions occur, instead of
+            caching changes and archiving them into a zip file at the end. This is useful for live trace viewing during test
+            execution.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.start(
+                    name=name,
+                    title=title,
+                    snapshots=snapshots,
+                    screenshots=screenshots,
+                    sources=sources,
+                    live=live,
+                )
+            )
+        )
+
+    def start_chunk(
+        self, *, title: typing.Optional[str] = None, name: typing.Optional[str] = None
+    ) -> None:
+        """Tracing.start_chunk
+
+        Start a new trace chunk. If you'd like to record multiple traces on the same `BrowserContext`, use
+        `tracing.start()` once, and then create multiple trace chunks with `tracing.start_chunk()` and
+        `tracing.stop_chunk()`.
+
+        **Usage**
+
+        ```py
+        context.tracing.start(screenshots=True, snapshots=True)
+        page = context.new_page()
+        page.goto(\"https://playwright.dev\")
+
+        context.tracing.start_chunk()
+        page.get_by_text(\"Get Started\").click()
+        # Everything between start_chunk and stop_chunk will be recorded in the trace.
+        context.tracing.stop_chunk(path = \"trace1.zip\")
+
+        context.tracing.start_chunk()
+        page.goto(\"http://example.com\")
+        # Save a second trace file with different actions.
+        context.tracing.stop_chunk(path = \"trace2.zip\")
+        ```
+
+        Parameters
+        ----------
+        title : Union[str, None]
+            Trace name to be shown in the Trace Viewer.
+        name : Union[str, None]
+            If specified, intermediate trace files are going to be saved into the files with the given name prefix inside the
+            `tracesDir` directory specified in `browser_type.launch()`. To specify the final trace zip file name, you
+            need to pass `path` option to `tracing.stop_chunk()` instead.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.start_chunk(title=title, name=name))
+        )
+
+    def stop_chunk(
+        self, *, path: typing.Optional[typing.Union[pathlib.Path, str]] = None
+    ) -> None:
+        """Tracing.stop_chunk
+
+        Stop the trace chunk. See `tracing.start_chunk()` for more details about multiple trace chunks.
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str, None]
+            Export trace collected since the last `tracing.start_chunk()` call into the file with the given path.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.stop_chunk(path=path)))
+
+    def stop(
+        self, *, path: typing.Optional[typing.Union[pathlib.Path, str]] = None
+    ) -> None:
+        """Tracing.stop
+
+        Stop tracing.
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str, None]
+            Export trace into the file with the given path.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.stop(path=path)))
+
+    def group(
+        self, name: str, *, location: typing.Optional[TracingGroupLocation] = None
+    ) -> "SyncContextManager":
+        """Tracing.group
+
+        **NOTE** Use `test.step` instead when available.
+
+        Creates a new group within the trace, assigning any subsequent API calls to this group, until
+        `tracing.group_end()` is called. Groups can be nested and will be visible in the trace viewer.
+
+        **Usage**
+
+        ```py
+        # All actions between group and group_end
+        # will be shown in the trace viewer as a group.
+        await page.context.tracing.group(\"Open Playwright.dev > API\")
+        await page.goto(\"https://playwright.dev/\")
+        await page.get_by_role(\"link\", name=\"API\").click()
+        await page.context.tracing.group_end()
+        ```
+
+        Parameters
+        ----------
+        name : str
+            Group name shown in the trace viewer.
+        location : Union[{file: str, line: Union[int, None], column: Union[int, None]}, None]
+            Specifies a custom location for the group to be shown in the trace viewer. Defaults to the location of the
+            `tracing.group()` call.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(self._impl_obj.group(name=name, location=location))
+        )
+
+    def group_end(self) -> None:
+        """Tracing.group_end
+
+        Closes the last group created by `tracing.group()`.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.group_end()))
+
+    def start_har(
+        self,
+        path: typing.Union[pathlib.Path, str],
+        *,
+        content: typing.Optional[Literal["attach", "embed", "omit"]] = None,
+        mode: typing.Optional[Literal["full", "minimal"]] = None,
+        url_filter: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> "SyncContextManager":
+        """Tracing.start_har
+
+        Start recording a HAR (HTTP Archive) of network activity in this context. The HAR file is written to disk when
+        `tracing.stop_har()` is called, or when the returned `Disposable` is disposed.
+
+        Only one HAR recording can be active at a time per `BrowserContext`.
+
+        **Usage**
+
+        ```py
+        context.tracing.start_har(\"trace.har\")
+        page = context.new_page()
+        page.goto(\"https://playwright.dev\")
+        context.tracing.stop_har()
+        ```
+
+        Parameters
+        ----------
+        path : Union[pathlib.Path, str]
+            Path on the filesystem to write the HAR file to. If the file name ends with `.zip`, the HAR is saved as a zip
+            archive with response bodies attached as separate files.
+        content : Union["attach", "embed", "omit", None]
+            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.
+        mode : Union["full", "minimal", None]
+            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`.
+        url_filter : Union[Pattern[str], str, None]
+            A glob or regex pattern to filter requests that are stored in the HAR. Defaults to none.
+
+        Returns
+        -------
+        SyncContextManager
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.start_har(
+                    path=path, content=content, mode=mode, urlFilter=url_filter
+                )
+            )
+        )
+
+    def stop_har(self) -> None:
+        """Tracing.stop_har
+
+        Stop HAR recording and save the HAR file to the path given to `tracing.start_har()`.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.stop_har()))
+
+
+mapping.register(TracingImpl, Tracing)
+
+
+class Locator(SyncBase):
+
+    @property
+    def page(self) -> "Page":
+        """Locator.page
+
+        A page this locator belongs to.
+
+        Returns
+        -------
+        Page
+        """
+        return mapping.from_impl(self._impl_obj.page)
+
+    @property
+    def first(self) -> "Locator":
+        """Locator.first
+
+        Returns locator to the first matching element.
+
+        Returns
+        -------
+        Locator
+        """
+        return mapping.from_impl(self._impl_obj.first)
+
+    @property
+    def last(self) -> "Locator":
+        """Locator.last
+
+        Returns locator to the last matching element.
+
+        **Usage**
+
+        ```py
+        banana = page.get_by_role(\"listitem\").last
+        ```
+
+        Returns
+        -------
+        Locator
+        """
+        return mapping.from_impl(self._impl_obj.last)
+
+    @property
+    def content_frame(self) -> "FrameLocator":
+        """Locator.content_frame
+
+        Returns a `FrameLocator` object pointing to the same `iframe` as this locator.
+
+        Useful when you have a `Locator` object obtained somewhere, and later on would like to interact with the content
+        inside the frame.
+
+        For a reverse operation, use `frame_locator.owner()`.
+
+        **Usage**
+
+        ```py
+        locator = page.locator(\"iframe[name=\\\"embedded\\\"]\")
+        # ...
+        frame_locator = locator.content_frame
+        frame_locator.get_by_role(\"button\").click()
+        ```
+
+        Returns
+        -------
+        FrameLocator
+        """
+        return mapping.from_impl(self._impl_obj.content_frame)
+
+    @property
+    def description(self) -> typing.Optional[str]:
+        """Locator.description
+
+        Returns locator description previously set with `locator.describe()`. Returns `null` if no custom
+        description has been set.
+
+        **Usage**
+
+        ```py
+        button = page.get_by_role(\"button\").describe(\"Subscribe button\")
+        print(button.description())  # \"Subscribe button\"
+
+        input = page.get_by_role(\"textbox\")
+        print(input.description())  # None
+        ```
+
+        Returns
+        -------
+        Union[str, None]
+        """
+        return mapping.from_maybe_impl(self._impl_obj.description)
+
+    def bounding_box(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[FloatRect]:
+        """Locator.bounding_box
+
+        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**
+
+        ```py
+        box = page.get_by_role(\"button\").bounding_box()
+        page.mouse.click(box[\"x\"] + box[\"width\"] / 2, box[\"y\"] + box[\"height\"] / 2)
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        Union[{x: float, y: float, width: float, height: float}, None]
+        """
+
+        return mapping.from_impl_nullable(
+            self._sync(self._impl_obj.bounding_box(timeout=to_milliseconds(timeout)))
+        )
+
+    def check(
+        self,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.check
+
+        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/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **Usage**
+
+        ```py
+        page.get_by_role(\"checkbox\").check()
+        ```
+
+        Parameters
+        ----------
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.check(
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
+                )
+            )
+        )
+
+    def click(
+        self,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        click_count: typing.Optional[int] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
+        """Locator.click
+
+        Click an element.
+
+        **Details**
+
+        This method clicks the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to click in the center of the element, or the specified `position`.
+        1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` 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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **Usage**
+
+        Click a button:
+
+        ```py
+        page.get_by_role(\"button\").click()
+        ```
+
+        Shift-right-click at a specific position on a canvas:
+
+        ```py
+        page.locator(\"canvas\").click(
+            button=\"right\", modifiers=[\"Shift\"], position={\"x\": 23, \"y\": 32}
+        )
+        ```
+
+        Parameters
+        ----------
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
+            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
+        button : Union["left", "middle", "right", None]
+            Defaults to `left`.
+        click_count : Union[int, None]
+            defaults to 1. See [UIEvent.detail].
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            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.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.click(
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    clickCount=click_count,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
+                    steps=steps,
+                )
+            )
+        )
+
+    def dblclick(
+        self,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        delay: typing.Optional[float] = None,
+        button: typing.Optional[Literal["left", "middle", "right"]] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
+        """Locator.dblclick
+
+        Double-click an element.
+
+        **Details**
+
+        This method double clicks the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to double click in the center of the element, or the specified `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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        **NOTE** `element.dblclick()` dispatches two `click` events and a single `dblclick` event.
+
+        Parameters
+        ----------
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        delay : Union[float, None]
+            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
+        button : Union["left", "middle", "right", None]
+            Defaults to `left`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between Playwright's current cursor
+            position and the provided destination. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.dblclick(
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    delay=delay,
+                    button=button,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
+                    steps=steps,
+                )
+            )
+        )
+
+    def dispatch_event(
+        self,
+        type: str,
+        event_init: typing.Optional[typing.Dict] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.dispatch_event
+
+        Programmatically dispatch an event on the matching element.
+
+        **Usage**
+
+        ```py
+        locator.dispatch_event(\"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`, initializes it with `eventInit`
+        properties and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
+
+        Since `eventInit` 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:
+
+        ```py
+        data_transfer = page.evaluate_handle(\"new DataTransfer()\")
+        locator.dispatch_event(\"#source\", \"dragstart\", {\"dataTransfer\": data_transfer})
+        ```
+
+        Parameters
+        ----------
+        type : str
+            DOM event type: `"click"`, `"dragstart"`, etc.
+        event_init : Union[Dict, None]
+            Optional event-specific initialization properties.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.dispatch_event(
+                    type=type,
+                    eventInit=mapping.to_impl(event_init),
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
+
+    def evaluate(
+        self,
+        expression: str,
+        arg: typing.Optional[typing.Any] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Any:
+        """Locator.evaluate
+
+        Execute JavaScript code in the page, taking the matching element as an argument.
+
+        **Details**
+
+        Returns the return value of `expression`, called with the matching element as a first argument, and `arg` as a
+        second argument.
+
+        If `expression` returns a [Promise], this method will wait for the promise to resolve and return its value.
+
+        If `expression` throws or rejects, this method throws.
+
+        **Usage**
+
+        Passing argument to `expression`:
+
+        ```py
+        result = page.get_by_testid(\"myId\").evaluate(\"(element, [x, y]) => element.textContent + ' ' + x * y\", [7, 8])
+        print(result) # prints \"myId text 56\"
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the locator before evaluating. Note that after locator is resolved,
+            evaluation itself is not limited by the timeout. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.evaluate(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
+
+    def evaluate_all(
+        self, expression: str, arg: typing.Optional[typing.Any] = None
+    ) -> typing.Any:
+        """Locator.evaluate_all
+
+        Execute JavaScript code in the page, taking all matching elements as an argument.
+
+        **Details**
+
+        Returns the return value of `expression`, called with an array of all matching elements as a first argument, and
+        `arg` as a second argument.
+
+        If `expression` returns a [Promise], this method will wait for the promise to resolve and return its value.
+
+        If `expression` throws or rejects, this method throws.
+
+        **Usage**
+
+        ```py
+        locator = page.locator(\"div\")
+        more_than_ten = locator.evaluate_all(\"(divs, min) => divs.length > min\", 10)
+        ```
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+
+        Returns
+        -------
+        Any
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.evaluate_all(
+                    expression=expression, arg=mapping.to_impl(arg)
+                )
+            )
+        )
+
+    def evaluate_handle(
+        self,
+        expression: str,
+        arg: typing.Optional[typing.Any] = None,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> "JSHandle":
+        """Locator.evaluate_handle
+
+        Execute JavaScript code in the page, taking the matching element as an argument, and return a `JSHandle` with the
+        result.
+
+        **Details**
+
+        Returns the return value of `expression` as a`JSHandle`, called with the matching element as a first argument, and
+        `arg` as a second argument.
+
+        The only difference between `locator.evaluate()` and `locator.evaluate_handle()` is that
+        `locator.evaluate_handle()` returns `JSHandle`.
+
+        If `expression` returns a [Promise], this method will wait for the promise to resolve and return its value.
+
+        If `expression` throws or rejects, this method throws.
+
+        See `page.evaluate_handle()` for more details.
+
+        Parameters
+        ----------
+        expression : str
+            JavaScript expression to be evaluated in the browser context. If the expression evaluates to a function, the
+            function is automatically invoked.
+        arg : Union[Any, None]
+            Optional argument to pass to `expression`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the locator before evaluating. Note that after locator is resolved,
+            evaluation itself is not limited by the timeout. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+
+        Returns
+        -------
+        JSHandle
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.evaluate_handle(
+                    expression=expression,
+                    arg=mapping.to_impl(arg),
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
+
+    def fill(
+        self,
+        value: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.fill
+
+        Set a value to the input field.
+
+        **Usage**
+
+        ```py
+        page.get_by_role(\"textbox\").fill(\"example value\")
+        ```
+
+        **Details**
+
+        This method waits for [actionability](https://playwright.dev/python/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.press_sequentially()`.
+
+        Parameters
+        ----------
+        value : str
+            Value to set for the `<input>`, `<textarea>` or `[contenteditable]` element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.fill(
+                    value=value,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    force=force,
+                )
+            )
+        )
+
+    def clear(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.clear
+
+        Clear the input field.
+
+        **Details**
+
+        This method waits for [actionability](https://playwright.dev/python/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**
+
+        ```py
+        page.get_by_role(\"textbox\").clear()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.clear(
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    force=force,
+                )
+            )
+        )
+
+    def locator(
+        self,
+        selector_or_locator: typing.Union[str, "Locator"],
+        *,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has: typing.Optional["Locator"] = None,
+        has_not: typing.Optional["Locator"] = None,
+    ) -> "Locator":
+        """Locator.locator
+
+        The method finds an element matching the specified selector in the locator's subtree. It also accepts filter
+        options, similar to `locator.filter()` method.
+
+        [Learn more about locators](https://playwright.dev/python/docs/locators).
+
+        Parameters
+        ----------
+        selector_or_locator : Union[Locator, str]
+            A selector or locator to use when resolving DOM element.
+        has_text : Union[Pattern[str], str, None]
+            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>`.
+        has_not_text : Union[Pattern[str], str, None]
+            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.
+        has : Union[Locator, None]
+            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`s.
+        has_not : Union[Locator, None]
+            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`s.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.locator(
+                selectorOrLocator=selector_or_locator,
+                hasText=has_text,
+                hasNotText=has_not_text,
+                has=has._impl_obj if has else None,
+                hasNot=has_not._impl_obj if has_not else None,
+            )
+        )
+
+    def get_by_alt_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.get_by_alt_text
+
+        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'>
+        ```
+
+        ```py
+        page.get_by_alt_text(\"Playwright logo\").click()
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_alt_text(text=text, exact=exact))
+
+    def get_by_label(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.get_by_label
+
+        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\">
+        ```
+
+        ```py
+        page.get_by_label(\"Username\").fill(\"john\")
+        page.get_by_label(\"Password\").fill(\"secret\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_label(text=text, exact=exact))
+
+    def get_by_placeholder(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.get_by_placeholder
+
+        Allows locating input elements by the placeholder text.
+
+        **Usage**
+
+        For example, consider the following DOM structure.
+
+        ```html
+        <input type=\"email\" placeholder=\"name@example.com\" />
+        ```
+
+        You can fill the input after locating it by the placeholder text:
+
+        ```py
+        page.get_by_placeholder(\"name@example.com\").fill(\"playwright@microsoft.com\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_placeholder(text=text, exact=exact)
+        )
+
+    def get_by_role(
+        self,
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
+        ],
+        *,
+        checked: typing.Optional[bool] = None,
+        disabled: typing.Optional[bool] = None,
+        expanded: typing.Optional[bool] = None,
+        include_hidden: typing.Optional[bool] = None,
+        level: typing.Optional[int] = None,
+        name: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        pressed: typing.Optional[bool] = None,
+        selected: typing.Optional[bool] = None,
+        exact: typing.Optional[bool] = None,
+        description: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+    ) -> "Locator":
+        """Locator.get_by_role
+
+        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 its implicit role:
+
+        ```py
+        expect(page.get_by_role(\"heading\", name=\"Sign up\")).to_be_visible()
+
+        page.get_by_role(\"checkbox\", name=\"Subscribe\").check()
+
+        page.get_by_role(\"button\", name=re.compile(\"submit\", re.IGNORECASE)).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.
+
+        Parameters
+        ----------
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        checked : Union[bool, None]
+            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).
+        disabled : Union[bool, None]
+            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).
+
+        expanded : Union[bool, None]
+            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).
+        include_hidden : Union[bool, None]
+            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).
+        level : Union[int, None]
+            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).
+        name : Union[Pattern[str], str, None]
+            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` to control this behavior.
+
+            Learn more about [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
+        pressed : Union[bool, None]
+            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).
+        selected : Union[bool, None]
+            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).
+        exact : Union[bool, None]
+            Whether `name` and `description` are matched exactly: case-sensitive and whole-string. Defaults to false. Ignored
+            when the value is a regular expression. Note that exact match still trims whitespace.
+        description : Union[Pattern[str], str, None]
+            Option to match the [accessible description](https://w3c.github.io/accname/#dfn-accessible-description). By
+            default, matching is case-insensitive and searches for a substring, use `exact` to control this behavior.
+
+            Learn more about [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.get_by_role(
+                role=role,
+                checked=checked,
+                disabled=disabled,
+                expanded=expanded,
+                includeHidden=include_hidden,
+                level=level,
+                name=name,
+                pressed=pressed,
+                selected=selected,
+                exact=exact,
+                description=description,
+            )
+        )
+
+    def get_by_test_id(
+        self, test_id: typing.Union[str, typing.Pattern[str]]
+    ) -> "Locator":
+        """Locator.get_by_test_id
+
+        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 its test id:
+
+        ```py
+        page.get_by_test_id(\"directions\").click()
+        ```
+
+        **Details**
+
+        By default, the `data-testid` attribute is used as a test id. Use `selectors.set_test_id_attribute()` to
+        configure a different test id attribute if necessary.
+
+        Parameters
+        ----------
+        test_id : Union[Pattern[str], str]
+            Id to locate the element by.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_test_id(testId=test_id))
+
+    def get_by_text(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.get_by_text
+
+        Allows locating elements that contain given text.
+
+        See also `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:
+
+        ```py
+        # Matches <span>
+        page.get_by_text(\"world\")
+
+        # Matches first <div>
+        page.get_by_text(\"Hello world\")
+
+        # Matches second <div>
+        page.get_by_text(\"Hello\", exact=True)
+
+        # Matches both <div>s
+        page.get_by_text(re.compile(\"Hello\"))
+
+        # Matches second <div>
+        page.get_by_text(re.compile(\"^hello$\", re.IGNORECASE))
+        ```
+
+        **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\">`.
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_text(text=text, exact=exact))
+
+    def get_by_title(
+        self,
+        text: typing.Union[str, typing.Pattern[str]],
+        *,
+        exact: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.get_by_title
+
+        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:
+
+        ```py
+        expect(page.get_by_title(\"Issues count\")).to_have_text(\"25 issues\")
+        ```
+
+        Parameters
+        ----------
+        text : Union[Pattern[str], str]
+            Text to locate the element for.
+        exact : Union[bool, None]
+            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.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.get_by_title(text=text, exact=exact))
+
+    def frame_locator(self, selector: str) -> "FrameLocator":
+        """Locator.frame_locator
+
+        When working with iframes, you can create a frame locator that will enter the iframe and allow locating elements in
+        that iframe:
+
+        **Usage**
+
+        ```py
+        locator = page.frame_locator(\"iframe\").get_by_text(\"Submit\")
+        locator.click()
+        ```
+
+        Parameters
+        ----------
+        selector : str
+            A selector to use when resolving DOM element.
+
+        Returns
+        -------
+        FrameLocator
+        """
+
+        return mapping.from_impl(self._impl_obj.frame_locator(selector=selector))
+
+    def element_handle(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> "ElementHandle":
+        """Locator.element_handle
+
+        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.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        ElementHandle
+        """
+
+        return mapping.from_impl(
+            self._sync(self._impl_obj.element_handle(timeout=to_milliseconds(timeout)))
+        )
+
+    def element_handles(self) -> typing.List["ElementHandle"]:
+        """Locator.element_handles
+
+        Resolves given locator to all matching DOM elements. If there are no matching elements, returns an empty list.
+
+        Returns
+        -------
+        List[ElementHandle]
+        """
+
+        return mapping.from_impl_list(self._sync(self._impl_obj.element_handles()))
+
+    def nth(self, index: int) -> "Locator":
+        """Locator.nth
+
+        Returns locator to the n-th matching element. It's zero based, `nth(0)` selects the first element.
+
+        **Usage**
+
+        ```py
+        banana = page.get_by_role(\"listitem\").nth(2)
+        ```
+
+        Parameters
+        ----------
+        index : int
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.nth(index=index))
+
+    def describe(self, description: str) -> "Locator":
+        """Locator.describe
+
+        Describes the locator, description is used in the trace viewer and reports. Returns the locator pointing to the
+        same element.
+
+        **Usage**
+
+        ```py
+        button = page.get_by_test_id(\"btn-sub\").describe(\"Subscribe button\")
+        button.click()
+        ```
+
+        Parameters
+        ----------
+        description : str
+            Locator description.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.describe(description=description))
+
+    def filter(
+        self,
+        *,
+        has_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has_not_text: typing.Optional[typing.Union[typing.Pattern[str], str]] = None,
+        has: typing.Optional["Locator"] = None,
+        has_not: typing.Optional["Locator"] = None,
+        visible: typing.Optional[bool] = None,
+    ) -> "Locator":
+        """Locator.filter
+
+        This method narrows existing locator according to the options, for example filters by text. It can be chained to
+        filter multiple times.
+
+        **Usage**
+
+        ```py
+        row_locator = page.locator(\"tr\")
+        # ...
+        row_locator.filter(has_text=\"text in column 1\").filter(
+            has=page.get_by_role(\"button\", name=\"column 2 button\")
+        ).screenshot()
+        ```
+
+        Parameters
+        ----------
+        has_text : Union[Pattern[str], str, None]
+            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>`.
+        has_not_text : Union[Pattern[str], str, None]
+            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.
+        has : Union[Locator, None]
+            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`s.
+        has_not : Union[Locator, None]
+            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`s.
+        visible : Union[bool, None]
+            Only matches visible or invisible elements.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(
+            self._impl_obj.filter(
+                hasText=has_text,
+                hasNotText=has_not_text,
+                has=has._impl_obj if has else None,
+                hasNot=has_not._impl_obj if has_not else None,
+                visible=visible,
+            )
+        )
+
+    def or_(self, locator: "Locator") -> "Locator":
+        """Locator.or_
+
+        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/python/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/python/docs/locators#strictness). In this case, you can use
+        `locator.first()` to only match one of them.
+
+        ```py
+        new_email = page.get_by_role(\"button\", name=\"New\")
+        dialog = page.get_by_text(\"Confirm security settings\")
+        expect(new_email.or_(dialog).first).to_be_visible()
+        if (dialog.is_visible()):
+          page.get_by_role(\"button\", name=\"Dismiss\").click()
+        new_email.click()
+        ```
+
+        Parameters
+        ----------
+        locator : Locator
+            Alternative locator to match.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.or_(locator=locator._impl_obj))
+
+    def and_(self, locator: "Locator") -> "Locator":
+        """Locator.and_
+
+        Creates a locator that matches both this locator and the argument locator.
+
+        **Usage**
+
+        The following example finds a button with a specific title.
+
+        ```py
+        button = page.get_by_role(\"button\").and_(page.get_by_title(\"Subscribe\"))
+        ```
+
+        Parameters
+        ----------
+        locator : Locator
+            Additional locator to match.
+
+        Returns
+        -------
+        Locator
+        """
+
+        return mapping.from_impl(self._impl_obj.and_(locator=locator._impl_obj))
+
+    def focus(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.focus
+
+        Calls [focus](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on the matching element.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.focus(timeout=to_milliseconds(timeout)))
+        )
+
+    def blur(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.blur
+
+        Calls [blur](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/blur) on the element.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.blur(timeout=to_milliseconds(timeout)))
+        )
+
+    def all(self) -> typing.List["Locator"]:
+        """Locator.all
+
+        When the locator points to a list of elements, this returns an array of locators, pointing to their respective
+        elements.
+
+        **NOTE** `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()` 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()`.
+
+        **Usage**
+
+        ```py
+        for li in page.get_by_role('listitem').all():
+          li.click();
+        ```
 
         Returns
         -------
-        List[JSHandle]
+        List[Locator]
         """
-        return mapping.from_impl_list(self._impl_obj.args)
 
-    @property
-    def location(self) -> "SourceLocation":
-        """ConsoleMessage.location
+        return mapping.from_impl_list(self._sync(self._impl_obj.all()))
+
+    def count(self) -> int:
+        """Locator.count
+
+        Returns the number of elements matching the locator.
+
+        **NOTE** If you need to assert the number of elements on the page, prefer `locator_assertions.to_have_count()`
+        to avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        count = page.get_by_role(\"listitem\").count()
+        ```
 
         Returns
         -------
-        {"url": str, "lineNumber": int, "columnNumber": int}
+        int
         """
-        return mapping.from_impl(self._impl_obj.location)
 
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.count()))
 
-mapping.register(ConsoleMessageImpl, ConsoleMessage)
+    def drag_to(
+        self,
+        target: "Locator",
+        *,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        trial: typing.Optional[bool] = None,
+        source_position: typing.Optional[Position] = None,
+        target_position: typing.Optional[Position] = None,
+        steps: typing.Optional[int] = None,
+    ) -> None:
+        """Locator.drag_to
+
+        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**
+
+        ```py
+        source = page.locator(\"#source\")
+        target = page.locator(\"#target\")
+
+        source.drag_to(target)
+        # or specify exact positions relative to the top-left corners of the elements:
+        source.drag_to(
+          target,
+          source_position={\"x\": 34, \"y\": 7},
+          target_position={\"x\": 10, \"y\": 20}
+        )
+        ```
 
+        Parameters
+        ----------
+        target : Locator
+            Locator of the element to drag to.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        source_position : Union[{x: float, y: float}, None]
+            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.
+        target_position : Union[{x: float, y: float}, None]
+            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.
+        steps : Union[int, None]
+            Defaults to 1. Sends `n` interpolated `mousemove` events to represent travel between the `mousedown` and `mouseup`
+            of the drag. When set to 1, emits a single `mousemove` event at the destination location.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.drag_to(
+                    target=target._impl_obj,
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    timeout=to_milliseconds(timeout),
+                    trial=trial,
+                    sourcePosition=source_position,
+                    targetPosition=target_position,
+                    steps=steps,
+                )
+            )
+        )
 
-class Dialog(SyncBase):
-    def __init__(self, obj: DialogImpl):
-        super().__init__(obj)
+    def drop(
+        self,
+        payload: DropPayload,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.drop
 
-    @property
-    def type(self) -> str:
-        """Dialog.type
+        Simulate an external drag-and-drop of files or clipboard-like data onto this locator.
 
-        Returns dialog's type, can be one of `alert`, `beforeunload`, `confirm` or `prompt`.
+        **Details**
+
+        Dispatches the native `dragenter`, `dragover`, and `drop` events at the center of the target element with a
+        synthetic [DataTransfer] carrying the provided files and/or data entries. Works cross-browser by constructing the
+        [DataTransfer] in the page context.
+
+        If the target element's `dragover` listener does not call `preventDefault()`, the target is considered to have
+        rejected the drop: Playwright dispatches `dragleave` and this method throws.
+
+        **Usage**
+
+        Drop a file buffer onto an upload area:
+
+        Drop plain text and a URL together:
+
+        Parameters
+        ----------
+        payload : {files: Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}, None], data: Union[Dict[str, str], None]}
+            Data to drop onto the target. Provide `files` (file paths or in-memory buffers), `data` (a mime-type → string map
+            for clipboard-like content such as `text/plain`, `text/html`, `text/uri-list`), or both.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.drop(
+                    payload=payload, position=position, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
+
+    def get_attribute(
+        self,
+        name: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Locator.get_attribute
+
+        Returns the matching element's attribute value.
+
+        **NOTE** If you need to assert an element's attribute, prefer `locator_assertions.to_have_attribute()` to
+        avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        Parameters
+        ----------
+        name : str
+            Attribute name to get the value for.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        str
+        Union[str, None]
         """
-        return mapping.from_maybe_impl(self._impl_obj.type)
 
-    @property
-    def message(self) -> str:
-        """Dialog.message
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.get_attribute(
+                    name=name, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-        A message displayed in the dialog.
+    def hover(
+        self,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.hover
+
+        Hover over the matching element.
+
+        **Usage**
+
+        ```py
+        page.get_by_role(\"link\").hover()
+        ```
+
+        **Details**
+
+        This method hovers over the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to hover over the center of the element, or the specified `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`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
+
+        Parameters
+        ----------
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.hover(
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    force=force,
+                    trial=trial,
+                )
+            )
+        )
+
+    def inner_html(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Locator.inner_html
+
+        Returns the [`element.innerHTML`](https://developer.mozilla.org/en-US/docs/Web/API/Element/innerHTML).
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.message)
 
-    @property
-    def default_value(self) -> str:
-        """Dialog.default_value
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.inner_html(timeout=to_milliseconds(timeout)))
+        )
 
-        If dialog is prompt, returns default prompt value. Otherwise, returns empty string.
+    def inner_text(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Locator.inner_text
+
+        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 `locator_assertions.to_have_text()` with
+        `useInnerText` option to avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
         str
         """
-        return mapping.from_maybe_impl(self._impl_obj.defaultValue)
 
-    def accept(self, prompt_text: str = None) -> NoneType:
-        """Dialog.accept
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.inner_text(timeout=to_milliseconds(timeout)))
+        )
 
-        Returns when the dialog has been accepted.
+    def input_value(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> str:
+        """Locator.input_value
+
+        Returns the value for the matching `<input>` or `<textarea>` or `<select>` element.
+
+        **NOTE** If you need to assert input value, prefer `locator_assertions.to_have_value()` to avoid flakiness.
+        See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        value = page.get_by_role(\"textbox\").input_value()
+        ```
+
+        **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.
 
         Parameters
         ----------
-        prompt_text : Optional[str]
-            A text to enter in prompt. Does not cause any effects if the dialog's `type` is not prompt. Optional.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        str
         """
 
-        try:
-            log_api("=> dialog.accept started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.accept(promptText=prompt_text))
-            )
-            log_api("<= dialog.accept succeded")
-            return result
-        except Exception as e:
-            log_api("<= dialog.accept failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.input_value(timeout=to_milliseconds(timeout)))
+        )
 
-    def dismiss(self) -> NoneType:
-        """Dialog.dismiss
+    def is_checked(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_checked
 
-        Returns when the dialog has been dismissed.
+        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 `locator_assertions.to_be_checked()` to avoid
+        flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        checked = page.get_by_role(\"checkbox\").is_checked()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+
+        Returns
+        -------
+        bool
         """
 
-        try:
-            log_api("=> dialog.dismiss started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.dismiss()))
-            log_api("<= dialog.dismiss succeded")
-            return result
-        except Exception as e:
-            log_api("<= dialog.dismiss failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.is_checked(timeout=to_milliseconds(timeout)))
+        )
 
+    def is_disabled(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_disabled
 
-mapping.register(DialogImpl, Dialog)
+        Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability#enabled).
 
+        **NOTE** If you need to assert that an element is disabled, prefer `locator_assertions.to_be_disabled()` to
+        avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
 
-class Download(SyncBase):
-    def __init__(self, obj: DownloadImpl):
-        super().__init__(obj)
+        **Usage**
 
-    @property
-    def url(self) -> str:
-        """Download.url
+        ```py
+        disabled = page.get_by_role(\"button\").is_disabled()
+        ```
 
-        Returns downloaded url.
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        str
+        bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.url)
 
-    @property
-    def suggested_filename(self) -> str:
-        """Download.suggested_filename
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.is_disabled(timeout=to_milliseconds(timeout)))
+        )
 
-        Returns suggested filename for this download. It is typically computed by the browser from the
-        `Content-Disposition` response header
-        or the `download` attribute. See the spec on whatwg. Different
-        browsers can use different logic for computing it.
+    def is_editable(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_editable
+
+        Returns whether the element is [editable](https://playwright.dev/python/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 `locator_assertions.to_be_editable()` to
+        avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        editable = page.get_by_role(\"textbox\").is_editable()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        str
+        bool
         """
-        return mapping.from_maybe_impl(self._impl_obj.suggestedFilename)
 
-    def delete(self) -> NoneType:
-        """Download.delete
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.is_editable(timeout=to_milliseconds(timeout)))
+        )
 
-        Deletes the downloaded file.
-        """
+    def is_enabled(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_enabled
 
-        try:
-            log_api("=> download.delete started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.delete()))
-            log_api("<= download.delete succeded")
-            return result
-        except Exception as e:
-            log_api("<= download.delete failed")
-            raise e
-
-    def failure(self) -> typing.Union[str, NoneType]:
-        """Download.failure
+        Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
+
+        **NOTE** If you need to assert that an element is enabled, prefer `locator_assertions.to_be_enabled()` to
+        avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
 
-        Returns download error if any.
+        ```py
+        enabled = page.get_by_role(\"button\").is_enabled()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        Optional[str]
+        bool
         """
 
-        try:
-            log_api("=> download.failure started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.failure()))
-            log_api("<= download.failure succeded")
-            return result
-        except Exception as e:
-            log_api("<= download.failure failed")
-            raise e
-
-    def path(self) -> typing.Union[str, NoneType]:
-        """Download.path
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.is_enabled(timeout=to_milliseconds(timeout)))
+        )
 
-        Returns path to the downloaded file in case of successful download.
+    def is_hidden(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_hidden
+
+        Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability#visible).
+
+        **NOTE** If you need to assert that element is hidden, prefer `locator_assertions.to_be_hidden()` to avoid
+        flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        hidden = page.get_by_role(\"button\").is_hidden()
+        ```
+
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Deprecated: This option is ignored. `locator.is_hidden()` does not wait for the element to become hidden and returns immediately.
 
         Returns
         -------
-        Optional[str]
+        bool
         """
 
-        try:
-            log_api("=> download.path started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.path()))
-            log_api("<= download.path succeded")
-            return result
-        except Exception as e:
-            log_api("<= download.path failed")
-            raise e
-
-    def save_as(self, path: typing.Union[str, pathlib.Path]) -> NoneType:
-        """Download.save_as
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.is_hidden(timeout=to_milliseconds(timeout)))
+        )
+
+    def is_visible(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> bool:
+        """Locator.is_visible
+
+        Returns whether the element is [visible](https://playwright.dev/python/docs/actionability#visible).
 
-        Saves the download to a user-specified path.
+        **NOTE** If you need to assert that element is visible, prefer `locator_assertions.to_be_visible()` to avoid
+        flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        visible = page.get_by_role(\"button\").is_visible()
+        ```
 
         Parameters
         ----------
-        path : Union[str, pathlib.Path]
-            Path where the download should be saved.
+        timeout : Union[float, None]
+            Deprecated: This option is ignored. `locator.is_visible()` does not wait for the element to become visible and returns immediately.
+
+        Returns
+        -------
+        bool
         """
 
-        try:
-            log_api("=> download.save_as started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.saveAs(path=path))
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.is_visible(timeout=to_milliseconds(timeout)))
+        )
+
+    def press(
+        self,
+        key: str,
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.press
+
+        Focuses the matching element and presses a combination of the keys.
+
+        **Usage**
+
+        ```py
+        page.get_by_role(\"textbox\").press(\"Backspace\")
+        ```
+
+        **Details**
+
+        Focuses the element, and then uses `keyboard.down()` and `keyboard.up()`.
+
+        `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` 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` in the upper case.
+
+        If `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.
+
+        Parameters
+        ----------
+        key : str
+            Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
+        delay : Union[float, None]
+            Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.press(
+                    key=key,
+                    delay=delay,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                )
             )
-            log_api("<= download.save_as succeded")
-            return result
-        except Exception as e:
-            log_api("<= download.save_as failed")
-            raise e
+        )
+
+    def screenshot(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        type: typing.Optional[Literal["jpeg", "png"]] = None,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        quality: typing.Optional[int] = None,
+        omit_background: typing.Optional[bool] = None,
+        animations: typing.Optional[Literal["allow", "disabled"]] = None,
+        caret: typing.Optional[Literal["hide", "initial"]] = None,
+        scale: typing.Optional[Literal["css", "device"]] = None,
+        mask: typing.Optional[typing.Sequence["Locator"]] = None,
+        mask_color: typing.Optional[str] = None,
+        style: typing.Optional[str] = None,
+    ) -> bytes:
+        """Locator.screenshot
 
+        Take a screenshot of the element matching the locator.
 
-mapping.register(DownloadImpl, Download)
+        **Usage**
+
+        ```py
+        page.get_by_role(\"link\").screenshot()
+        ```
+
+        Disable animations and save screenshot to a file:
+
+        ```py
+        page.get_by_role(\"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.
 
-class Video(SyncBase):
-    def __init__(self, obj: VideoImpl):
-        super().__init__(obj)
+        This method waits for the [actionability](https://playwright.dev/python/docs/actionability) checks, then scrolls element into view before taking
+        a screenshot. If the element is detached from DOM, the method throws an error.
 
-    def path(self) -> str:
-        """Video.path
+        Returns the buffer with the captured screenshot.
 
-        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.
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        type : Union["jpeg", "png", None]
+            Specify screenshot type, defaults to `png`.
+        path : Union[pathlib.Path, str, None]
+            The file path to save the image to. The screenshot type will be inferred from file extension. If `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.
+        quality : Union[int, None]
+            The quality of the image, between 0-100. Not applicable to `png` images.
+        omit_background : Union[bool, None]
+            Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images.
+            Defaults to `false`.
+        animations : Union["allow", "disabled", None]
+            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.
+        caret : Union["hide", "initial", None]
+            When set to `"hide"`, screenshot will hide text caret. When set to `"initial"`, text caret behavior will not be
+            changed.  Defaults to `"hide"`.
+        scale : Union["css", "device", None]
+            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"`.
+        mask : Union[Sequence[Locator], None]
+            Specify locators that should be masked when the screenshot is taken. Masked elements will be overlaid with a pink
+            box `#FF00FF` (customized by `maskColor`) that completely covers its bounding box. The mask is also applied to
+            invisible elements, see [Matching only visible elements](../locators.md#matching-only-visible-elements) to disable
+            that.
+        mask_color : Union[str, None]
+            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`.
+        style : Union[str, None]
+            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.
 
         Returns
         -------
-        str
+        bytes
         """
 
-        try:
-            log_api("=> video.path started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.path()))
-            log_api("<= video.path succeded")
-            return result
-        except Exception as e:
-            log_api("<= video.path failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.screenshot(
+                    timeout=to_milliseconds(timeout),
+                    type=type,
+                    path=path,
+                    quality=quality,
+                    omitBackground=omit_background,
+                    animations=animations,
+                    caret=caret,
+                    scale=scale,
+                    mask=mapping.to_impl(mask),
+                    maskColor=mask_color,
+                    style=style,
+                )
+            )
+        )
+
+    def aria_snapshot(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        depth: typing.Optional[int] = None,
+        mode: typing.Optional[Literal["ai", "default"]] = None,
+        boxes: typing.Optional[bool] = None,
+    ) -> str:
+        """Locator.aria_snapshot
 
+        Captures the aria snapshot of the given element. Read more about [aria snapshots](https://playwright.dev/python/docs/aria-snapshots) and
+        `locator_assertions.to_match_aria_snapshot()` for the corresponding assertion.
 
-mapping.register(VideoImpl, Video)
+        **Usage**
 
+        ```py
+        page.get_by_role(\"link\").aria_snapshot()
+        ```
 
-class BindingCall(SyncBase):
-    def __init__(self, obj: BindingCallImpl):
-        super().__init__(obj)
+        **Details**
 
-    def call(self, func: typing.Callable) -> NoneType:
+        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.
 
-        try:
-            log_api("=> binding_call.call started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.call(func=self._wrap_handler(func)))
-            )
-            log_api("<= binding_call.call succeded")
-            return result
-        except Exception as e:
-            log_api("<= binding_call.call failed")
-            raise e
+        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:
 
-mapping.register(BindingCallImpl, BindingCall)
+        ```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\"
+        ```
 
-class Page(SyncBase):
-    def __init__(self, obj: PageImpl):
-        super().__init__(obj)
+        An AI-optimized snapshot, controlled by `mode`, is different from a default snapshot:
+        1. Includes element references `[ref=e2]`. 2. Does not wait for an element matching the locator, and throws when
+           no elements match. 3. Includes snapshots of `<iframe>`s inside the target.
 
-    @property
-    def accessibility(self) -> "Accessibility":
-        """Page.accessibility
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        depth : Union[int, None]
+            When specified, limits the depth of the snapshot.
+        mode : Union["ai", "default", None]
+            When set to `"ai"`, returns a snapshot optimized for AI consumption. Defaults to `"default"`. See details for more
+            information.
+        boxes : Union[bool, None]
+            When `true`, appends each element's bounding box as `[box=x,y,width,height]` to the snapshot. Coordinates are
+            relative to the viewport, in CSS pixels, as returned by
+            [`Element.getBoundingClientRect()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
+            Defaults to `false`.
 
         Returns
         -------
-        Accessibility
+        str
         """
-        return mapping.from_impl(self._impl_obj.accessibility)
 
-    @property
-    def keyboard(self) -> "Keyboard":
-        """Page.keyboard
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.aria_snapshot(
+                    timeout=to_milliseconds(timeout),
+                    depth=depth,
+                    mode=mode,
+                    boxes=boxes,
+                )
+            )
+        )
 
-        Returns
-        -------
-        Keyboard
-        """
-        return mapping.from_impl(self._impl_obj.keyboard)
+    def normalize(self) -> "Locator":
+        """Locator.normalize
 
-    @property
-    def mouse(self) -> "Mouse":
-        """Page.mouse
+        Returns a new locator that uses best practices for referencing the matched element, prioritizing test ids, aria
+        roles, and other user-facing attributes over CSS selectors. This is useful for converting implementation-detail
+        selectors into more resilient, human-readable locators.
 
         Returns
         -------
-        Mouse
+        Locator
         """
-        return mapping.from_impl(self._impl_obj.mouse)
 
-    @property
-    def touchscreen(self) -> "Touchscreen":
-        """Page.touchscreen
+        return mapping.from_impl(self._sync(self._impl_obj.normalize()))
 
-        Returns
-        -------
-        Touchscreen
-        """
-        return mapping.from_impl(self._impl_obj.touchscreen)
+    def scroll_into_view_if_needed(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.scroll_into_view_if_needed
 
-    @property
-    def context(self) -> "BrowserContext":
-        """Page.context
+        This method waits for [actionability](https://playwright.dev/python/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`.
 
-        Get the browser context that the page belongs to.
+        See [scrolling](https://playwright.dev/python/docs/input#scrolling) for alternative ways to scroll.
 
-        Returns
-        -------
-        BrowserContext
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
         """
-        return mapping.from_impl(self._impl_obj.context)
 
-    @property
-    def main_frame(self) -> "Frame":
-        """Page.main_frame
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.scroll_into_view_if_needed(
+                    timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-        The page's main frame. Page is guaranteed to have a main frame which persists during navigations.
+    def select_option(
+        self,
+        value: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        *,
+        index: typing.Optional[typing.Union[int, typing.Sequence[int]]] = None,
+        label: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
+        element: typing.Optional[
+            typing.Union["ElementHandle", typing.Sequence["ElementHandle"]]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        force: typing.Optional[bool] = None,
+    ) -> typing.List[str]:
+        """Locator.select_option
 
-        Returns
-        -------
-        Frame
-        """
-        return mapping.from_impl(self._impl_obj.mainFrame)
+        Selects option or options in `<select>`.
 
-    @property
-    def frames(self) -> typing.List["Frame"]:
-        """Page.frames
+        **Details**
 
-        An array of all frames attached to the page.
+        This method waits for [actionability](https://playwright.dev/python/docs/actionability) checks, waits until all specified options are present in
+        the `<select>` element and selects these options.
 
-        Returns
-        -------
-        List[Frame]
-        """
-        return mapping.from_impl_list(self._impl_obj.frames)
+        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.
 
-    @property
-    def url(self) -> str:
-        """Page.url
+        Returns the array of option values that have been successfully selected.
 
-        Shortcut for main frame's frame.url().
+        Triggers a `change` and `input` event once all the provided options have been selected.
 
-        Returns
-        -------
-        str
-        """
-        return mapping.from_maybe_impl(self._impl_obj.url)
+        **Usage**
 
-    @property
-    def workers(self) -> typing.List["Worker"]:
-        """Page.workers
+        ```html
+        <select multiple>
+          <option value=\"red\">Red</option>
+          <option value=\"green\">Green</option>
+          <option value=\"blue\">Blue</option>
+        </select>
+        ```
 
-        This method returns all of the dedicated WebWorkers
-        associated with the page.
+        ```py
+        # single selection matching the value or label
+        element.select_option(\"blue\")
+        # single selection matching the label
+        element.select_option(label=\"blue\")
+        # multiple selection for blue, red and second option
+        element.select_option(value=[\"red\", \"green\", \"blue\"])
+        ```
 
-        **NOTE** This does not contain ServiceWorkers
+        Parameters
+        ----------
+        value : Union[Sequence[str], str, None]
+            Options to select by value. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        index : Union[Sequence[int], int, None]
+            Options to select by index. Optional.
+        label : Union[Sequence[str], str, None]
+            Options to select by label. If the `<select>` has the `multiple` attribute, all given options are selected,
+            otherwise only the first option matching one of the passed options is selected. Optional.
+        element : Union[ElementHandle, Sequence[ElementHandle], None]
+            Option elements to select. Optional.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
 
         Returns
         -------
-        List[Worker]
+        List[str]
         """
-        return mapping.from_impl_list(self._impl_obj.workers)
-
-    @property
-    def video(self) -> typing.Union["Video", NoneType]:
-        """Page.video
 
-        Video object associated with this page.
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.select_option(
+                    value=mapping.to_impl(value),
+                    index=mapping.to_impl(index),
+                    label=mapping.to_impl(label),
+                    element=mapping.to_impl(element),
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                    force=force,
+                )
+            )
+        )
 
-        Returns
-        -------
-        Optional[Video]
-        """
-        return mapping.from_impl_nullable(self._impl_obj.video)
+    def select_text(
+        self,
+        *,
+        force: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """Locator.select_text
 
-    def opener(self) -> typing.Union["Page", NoneType]:
-        """Page.opener
+        This method waits for [actionability](https://playwright.dev/python/docs/actionability) checks, then focuses the element and selects all its
+        text content.
 
-        Returns the opener for popup pages and `null` for others. If the opener has been closed already the promise may resolve
-        to `null`.
+        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.
 
-        Returns
-        -------
-        Optional[Page]
+        Parameters
+        ----------
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
         """
 
-        try:
-            log_api("=> page.opener started")
-            result = mapping.from_impl_nullable(self._sync(self._impl_obj.opener()))
-            log_api("<= page.opener succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.opener failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.select_text(
+                    force=force, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def frame(
+    def set_input_files(
         self,
-        name: str = None,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-    ) -> typing.Union["Frame", NoneType]:
-        """Page.frame
+        files: typing.Union[
+            str,
+            pathlib.Path,
+            FilePayload,
+            typing.Sequence[typing.Union[str, pathlib.Path]],
+            typing.Sequence[FilePayload],
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.set_input_files
 
-        Returns frame matching the specified criteria. Either `name` or `url` must be specified.
+        Upload file or multiple files into `<input type=file>`. For inputs with a `[webkitdirectory]` attribute, only a
+        single directory path is supported.
 
-        Parameters
-        ----------
-        name : Optional[str]
-            frame name specified in the `iframe`'s `name` attribute
-        url : Union[str, Pattern, Callable[[str], bool], NoneType]
-            A glob pattern, regex pattern or predicate receiving frame's `url` as a URL object.
+        **Usage**
 
-        Returns
-        -------
-        Optional[Frame]
-        """
+        ```py
+        # Select one file
+        page.get_by_label(\"Upload file\").set_input_files('myfile.pdf')
 
-        try:
-            log_api("=> page.frame started")
-            result = mapping.from_impl_nullable(
-                self._impl_obj.frame(name=name, url=self._wrap_handler(url))
-            )
-            log_api("<= page.frame succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.frame failed")
-            raise e
+        # Select multiple files
+        page.get_by_label(\"Upload files\").set_input_files(['file1.txt', 'file2.txt'])
 
-    def set_default_navigation_timeout(self, timeout: int) -> NoneType:
-        """Page.set_default_navigation_timeout
+        # Select a directory
+        page.get_by_label(\"Upload directory\").set_input_files('mydir')
 
-        This setting will change the default maximum navigation time for the following methods and related shortcuts:
+        # Remove all the selected files
+        page.get_by_label(\"Upload file\").set_input_files([])
+
+        # Upload buffer from memory
+        page.get_by_label(\"Upload file\").set_input_files(
+            files=[
+                {\"name\": \"test.txt\", \"mimeType\": \"text/plain\", \"buffer\": b\"this is a test\"}
+            ],
+        )
+        ```
 
-        page.go_back([options])
-        page.go_forward([options])
-        page.goto(url[, options])
-        page.reload([options])
-        page.set_content(html[, options])
-        page.wait_for_navigation([options])
+        **Details**
 
-        **NOTE** page.set_default_navigation_timeout(timeout) takes priority over page.set_default_timeout(timeout),
-        browser_context.set_default_timeout(timeout) and browser_context.set_default_navigation_timeout(timeout).
+        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` 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.
 
         Parameters
         ----------
-        timeout : int
-            Maximum navigation time in milliseconds
-        """
-
-        try:
-            log_api("=> page.set_default_navigation_timeout started")
-            result = mapping.from_maybe_impl(
-                self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
+        files : Union[Sequence[Union[pathlib.Path, str]], Sequence[{name: str, mimeType: str, buffer: bytes}], pathlib.Path, str, {name: str, mimeType: str, buffer: bytes}]
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_input_files(
+                    files=mapping.to_impl(files),
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                )
             )
-            log_api("<= page.set_default_navigation_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_default_navigation_timeout failed")
-            raise e
+        )
 
-    def set_default_timeout(self, timeout: int) -> NoneType:
-        """Page.set_default_timeout
+    def tap(
+        self,
+        *,
+        modifiers: typing.Optional[
+            typing.Sequence[Literal["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]]
+        ] = None,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.tap
 
-        This setting will change the default maximum time for all the methods accepting `timeout` option.
+        Perform a tap gesture on the element matching the locator. For examples of emulating other gestures by manually
+        dispatching touch events, see the [emulating legacy touch events](https://playwright.dev/python/docs/touch-events) page.
 
-        **NOTE** page.set_default_navigation_timeout(timeout) takes priority over page.set_default_timeout(timeout).
+        **Details**
 
-        Parameters
-        ----------
-        timeout : int
-            Maximum time in milliseconds
-        """
+        This method taps the element by performing the following steps:
+        1. Wait for [actionability](https://playwright.dev/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.touchscreen` to tap the center of the element, or the specified `position`.
 
-        try:
-            log_api("=> page.set_default_timeout started")
-            result = mapping.from_maybe_impl(
-                self._impl_obj.setDefaultTimeout(timeout=timeout)
-            )
-            log_api("<= page.set_default_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_default_timeout failed")
-            raise e
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-    def query_selector(self, selector: str) -> typing.Union["ElementHandle", NoneType]:
-        """Page.query_selector
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
-        The method finds an element matching the specified selector within the page. If no elements match the selector, the
-        return value resolves to `null`.
-        Shortcut for main frame's frame.$(selector).
+        **NOTE** `element.tap()` requires that the `hasTouch` option of the browser context be set to true.
 
         Parameters
         ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-
-        Returns
-        -------
-        Optional[ElementHandle]
-        """
-
-        try:
-            log_api("=> page.query_selector started")
-            result = mapping.from_impl_nullable(
-                self._sync(self._impl_obj.querySelector(selector=selector))
+        modifiers : Union[Sequence[Union["Alt", "Control", "ControlOrMeta", "Meta", "Shift"]], None]
+            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.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) 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.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.tap(
+                    modifiers=mapping.to_impl(modifiers),
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
+                )
             )
-            log_api("<= page.query_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.query_selector failed")
-            raise e
+        )
 
-    def query_selector_all(self, selector: str) -> typing.List["ElementHandle"]:
-        """Page.query_selector_all
+    def text_content(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> typing.Optional[str]:
+        """Locator.text_content
 
-        The method finds all elements matching the specified selector within the page. If no elements match the selector, the
-        return value resolves to `[]`.
-        Shortcut for main frame's frame.$$(selector).
+        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 `locator_assertions.to_have_text()` to avoid
+        flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
 
         Parameters
         ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
 
         Returns
         -------
-        List[ElementHandle]
+        Union[str, None]
         """
 
-        try:
-            log_api("=> page.query_selector_all started")
-            result = mapping.from_impl_list(
-                self._sync(self._impl_obj.querySelectorAll(selector=selector))
-            )
-            log_api("<= page.query_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.query_selector_all failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.text_content(timeout=to_milliseconds(timeout)))
+        )
 
-    def wait_for_selector(
+    def type(
         self,
-        selector: str,
-        timeout: int = None,
-        state: Literal["attached", "detached", "hidden", "visible"] = None,
-    ) -> typing.Union["ElementHandle", NoneType]:
-        """Page.wait_for_selector
+        text: str,
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.type
 
-        Returns when element specified by selector satisfies `state` option. Resolves to `null` if waiting for `hidden` or
-        `detached`.
-        Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at
-        the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the
-        selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.
-        This method works across navigations:
+        Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the
+        text.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        state : Optional[Literal['attached', 'detached', 'hidden', 'visible']]
-            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.
+        To press a special key, like `Control` or `ArrowDown`, use `locator.press()`.
 
-        Returns
-        -------
-        Optional[ElementHandle]
-        """
+        **Usage**
 
-        try:
-            log_api("=> page.wait_for_selector started")
-            result = mapping.from_impl_nullable(
-                self._sync(
-                    self._impl_obj.waitForSelector(
-                        selector=selector, timeout=timeout, state=state
-                    )
+        Parameters
+        ----------
+        text : str
+            A text to type into a focused element.
+        delay : Union[float, None]
+            Time to wait between key presses in milliseconds. Defaults to 0.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.type(
+                    text=text,
+                    delay=delay,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
                 )
             )
-            log_api("<= page.wait_for_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_selector failed")
-            raise e
+        )
 
-    def dispatch_event(
+    def press_sequentially(
         self,
-        selector: str,
-        type: str,
-        event_init: typing.Dict = None,
-        timeout: int = None,
-    ) -> NoneType:
-        """Page.dispatch_event
+        text: str,
+        *,
+        delay: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        no_wait_after: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.press_sequentially
 
-        The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the elment, `click`
-        is dispatched. This is equivalend to calling
-        element.click().
-        Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
-        and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
-        Since `eventInit` is event-specific, please refer to the events documentation for the lists of initial properties:
+        **NOTE** In most cases, you should use `locator.fill()` instead. You only need to press keys one by one if
+        there is special keyboard handling on the page.
 
-        DragEvent
-        FocusEvent
-        KeyboardEvent
-        MouseEvent
-        PointerEvent
-        TouchEvent
-        Event
+        Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the
+        text.
 
-        You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
+        To press a special key, like `Control` or `ArrowDown`, use `locator.press()`.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        type : str
-            DOM event type: `"click"`, `"dragstart"`, etc.
-        event_init : Optional[Dict]
-            Optional event-specific initialization properties.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        """
+        **Usage**
 
-        try:
-            log_api("=> page.dispatch_event started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.dispatchEvent(
-                        selector=selector,
-                        type=type,
-                        eventInit=mapping.to_impl(event_init),
-                        timeout=timeout,
-                    )
-                )
-            )
-            log_api("<= page.dispatch_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.dispatch_event failed")
-            raise e
+        ```py
+        locator.press_sequentially(\"hello\") # types instantly
+        locator.press_sequentially(\"world\", delay=100) # types slower, like a user
+        ```
 
-    def evaluate(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
-    ) -> typing.Any:
-        """Page.evaluate
+        An example of typing into a text field and then submitting the form:
 
-        Returns the value of the `pageFunction` invacation.
-        If the function passed to the `page.evaluate` returns a Promise, then `page.evaluate` would wait for the promise to
-        resolve and return its value.
-        If the function passed to the `page.evaluate` returns a non-Serializable value, then `page.evaluate` resolves to
-        `undefined`. DevTools Protocol also supports transferring some additional values that are not serializable by `JSON`:
-        `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
-        Passing argument to `pageFunction`:
-        A string can also be passed in instead of a function:
-        ElementHandle instances can be passed as an argument to the `page.evaluate`:
-        Shortcut for main frame's frame.evaluate(pageFunction[, arg]).
+        ```py
+        locator = page.get_by_label(\"Password\")
+        locator.press_sequentially(\"my password\")
+        locator.press(\"Enter\")
+        ```
 
         Parameters
         ----------
-        expression : str
-            Function to be evaluated in the page context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
-
-        Returns
-        -------
-        Any
-        """
+        text : str
+            String of characters to sequentially press into a focused element.
+        delay : Union[float, None]
+            Time to wait between key presses in milliseconds. Defaults to 0.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.press_sequentially(
+                    text=text,
+                    delay=delay,
+                    timeout=to_milliseconds(timeout),
+                    noWaitAfter=no_wait_after,
+                )
+            )
+        )
 
-        try:
-            log_api("=> page.evaluate started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.evaluate(
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= page.evaluate succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.evaluate failed")
-            raise e
+    def uncheck(
+        self,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.uncheck
 
-    def evaluate_handle(
-        self, expression: str, arg: typing.Any = None, force_expr: bool = None
-    ) -> "JSHandle":
-        """Page.evaluate_handle
+        Ensure that checkbox or radio element is unchecked.
 
-        Returns the value of the `pageFunction` invacation as in-page object (JSHandle).
-        The only difference between `page.evaluate` and `page.evaluate_handle` is that `page.evaluate_handle` returns in-page
-        object (JSHandle).
-        If the function passed to the `page.evaluate_handle` returns a Promise, then `page.evaluate_handle` would wait for the
-        promise to resolve and return its value.
-        A string can also be passed in instead of a function:
-        JSHandle instances can be passed as an argument to the `page.evaluate_handle`:
+        **Usage**
 
-        Parameters
-        ----------
-        expression : str
-            Function to be evaluated in the page context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+        ```py
+        page.get_by_role(\"checkbox\").uncheck()
+        ```
 
-        Returns
-        -------
-        JSHandle
-        """
+        **Details**
 
-        try:
-            log_api("=> page.evaluate_handle started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.evaluateHandle(
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= page.evaluate_handle succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.evaluate_handle failed")
-            raise e
+        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/python/docs/actionability) checks on the element, unless `force` option is set.
+        1. Scroll the element into view if needed.
+        1. Use `page.mouse` to click in the center of the element.
+        1. Ensure that the element is now unchecked. If not, this method throws.
 
-    def eval_on_selector(
-        self,
-        selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-    ) -> typing.Any:
-        """Page.eval_on_selector
+        If the element is detached from the DOM at any moment during the action, this method throws.
 
-        The method finds an element matching the specified selector within the page and passes it as a first argument to
-        `pageFunction`. If no elements match the selector, the method throws an error. Returns the value of `pageFunction`.
-        If `pageFunction` returns a Promise, then `page.$eval` would wait for the promise to resolve and return its value.
-        Examples:
-        Shortcut for main frame's frame.$eval(selector, pageFunction[, arg]).
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
         Parameters
         ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.uncheck(
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
+                )
+            )
+        )
+
+    def all_inner_texts(self) -> typing.List[str]:
+        """Locator.all_inner_texts
+
+        Returns an array of `node.innerText` values for all matching nodes.
+
+        **NOTE** If you need to assert text on the page, prefer `locator_assertions.to_have_text()` with
+        `useInnerText` option to avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        texts = page.get_by_role(\"link\").all_inner_texts()
+        ```
 
         Returns
         -------
-        Any
+        List[str]
         """
 
-        try:
-            log_api("=> page.eval_on_selector started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.evalOnSelector(
-                        selector=selector,
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= page.eval_on_selector succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.eval_on_selector failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.all_inner_texts()))
 
-    def eval_on_selector_all(
-        self,
-        selector: str,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-    ) -> typing.Any:
-        """Page.eval_on_selector_all
+    def all_text_contents(self) -> typing.List[str]:
+        """Locator.all_text_contents
 
-        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`. Returns the result of `pageFunction` invocation.
-        If `pageFunction` returns a Promise, then `page.$$eval` would wait for the promise to resolve and return its value.
-        Examples:
+        Returns an array of `node.textContent` values for all matching nodes.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to query for. See working with selectors for more details.
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
+        **NOTE** If you need to assert text on the page, prefer `locator_assertions.to_have_text()` to avoid
+        flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
+        **Usage**
+
+        ```py
+        texts = page.get_by_role(\"link\").all_text_contents()
+        ```
 
         Returns
         -------
-        Any
+        List[str]
         """
 
-        try:
-            log_api("=> page.eval_on_selector_all started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.evalOnSelectorAll(
-                        selector=selector,
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                    )
-                )
-            )
-            log_api("<= page.eval_on_selector_all succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.eval_on_selector_all failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.all_text_contents()))
 
-    def add_script_tag(
+    def wait_for(
         self,
-        url: str = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content: str = None,
-        type: str = None,
-    ) -> "ElementHandle":
-        """Page.add_script_tag
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        state: typing.Optional[
+            Literal["attached", "detached", "hidden", "visible"]
+        ] = None,
+    ) -> None:
+        """Locator.wait_for
 
-        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.
-        Shortcut for main frame's frame.add_script_tag(script).
+        Returns when element specified by locator satisfies the `state` option.
+
+        If target element already satisfies the condition, the method returns immediately. Otherwise, waits for up to
+        `timeout` milliseconds until the condition is met.
+
+        **Usage**
+
+        ```py
+        order_sent = page.locator(\"#order-sent\")
+        order_sent.wait_for()
+        ```
 
         Parameters
         ----------
-        url : Optional[str]
-            URL of a script to be added.
-        path : Union[str, pathlib.Path, NoneType]
-            Path to the JavaScript file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory.
-        content : Optional[str]
-            Raw JavaScript content to be injected into frame.
-        type : Optional[str]
-            Script type. Use 'module' in order to load a Javascript ES6 module. See script for more details.
-
-        Returns
-        -------
-        ElementHandle
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        state : Union["attached", "detached", "hidden", "visible", None]
+            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.
         """
 
-        try:
-            log_api("=> page.add_script_tag started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.addScriptTag(
-                        url=url, path=path, content=content, type=type
-                    )
-                )
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.wait_for(timeout=to_milliseconds(timeout), state=state)
             )
-            log_api("<= page.add_script_tag succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.add_script_tag failed")
-            raise e
+        )
 
-    def add_style_tag(
+    def set_checked(
         self,
-        url: str = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        content: str = None,
-    ) -> "ElementHandle":
-        """Page.add_style_tag
+        checked: bool,
+        *,
+        position: typing.Optional[Position] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        force: typing.Optional[bool] = None,
+        no_wait_after: typing.Optional[bool] = None,
+        trial: typing.Optional[bool] = None,
+    ) -> None:
+        """Locator.set_checked
+
+        Set the state of a checkbox or a radio element.
+
+        **Usage**
+
+        ```py
+        page.get_by_role(\"checkbox\").set_checked(True)
+        ```
 
-        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.
-        Shortcut for main frame's frame.add_style_tag(style).
+        **Details**
 
-        Parameters
-        ----------
-        url : Optional[str]
-            URL of the `<link>` tag.
-        path : Union[str, pathlib.Path, NoneType]
-            Path to the CSS file to be injected into frame. If `path` is a relative path, then it is resolved relative to current working directory.
-        content : Optional[str]
-            Raw CSS content to be injected into frame.
+        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/python/docs/actionability) checks on the matched element, unless `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` to click in the center of the element.
+        1. Ensure that the element is now checked or unchecked. If not, this method throws.
 
-        Returns
-        -------
-        ElementHandle
-        """
+        When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`.
+        Passing zero timeout disables this.
 
-        try:
-            log_api("=> page.add_style_tag started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.addStyleTag(url=url, path=path, content=content)
+        Parameters
+        ----------
+        checked : bool
+            Whether to check or uncheck the checkbox.
+        position : Union[{x: float, y: float}, None]
+            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of
+            the element.
+        timeout : Union[float, None]
+            Maximum time in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout. The default value can
+            be changed by using the `browser_context.set_default_timeout()` or `page.set_default_timeout()` methods.
+        force : Union[bool, None]
+            Whether to bypass the [actionability](../actionability.md) checks. Defaults to `false`.
+        no_wait_after : Union[bool, None]
+            This option has no effect.
+            Deprecated: This option has no effect.
+        trial : Union[bool, None]
+            When set, this method only performs the [actionability](../actionability.md) checks and skips the action. Defaults
+            to `false`. Useful to wait until the element is ready for the action without performing it.
+        """
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.set_checked(
+                    checked=checked,
+                    position=position,
+                    timeout=to_milliseconds(timeout),
+                    force=force,
+                    noWaitAfter=no_wait_after,
+                    trial=trial,
                 )
             )
-            log_api("<= page.add_style_tag succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.add_style_tag failed")
-            raise e
+        )
 
-    def expose_function(self, name: str, binding: typing.Callable) -> NoneType:
-        """Page.expose_function
+    def highlight(self, *, style: typing.Optional[str] = None) -> None:
+        """Locator.highlight
 
-        The method adds a function called `name` on the `window` object of every frame in the page. When called, the function
-        executes `playwrightFunction` in Node.js and returns a Promise which resolves to the return value of
-        `playwrightFunction`.
-        If the `playwrightFunction` returns a Promise, it will be awaited.
-        See browser_context.expose_function(name, playwrightFunction) for context-wide exposed function.
+        Highlight the corresponding element(s) on the screen. Useful for debugging, don't commit the code that uses
+        `locator.highlight()`.
 
-        **NOTE** Functions installed via `page.expose_function` survive navigations.
+        Parameters
+        ----------
+        style : Union[str, None]
+            Additional inline CSS applied to the highlight overlay, e.g. `"outline: 2px dashed red"`.
+        """
 
-        An example of adding an `md5` function to the page:
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.highlight(style=style))
+        )
 
-        An example of adding a `window.readfile` function to the page:
+    def hide_highlight(self) -> None:
+        """Locator.hide_highlight
 
-        Parameters
-        ----------
-        name : str
-            Name of the function on the window object
-        binding : Callable
-            Callback function which will be called in Playwright's context.
+        Hides the element highlight previously added by `locator.highlight()`.
         """
 
-        try:
-            log_api("=> page.expose_function started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.exposeFunction(
-                        name=name, binding=self._wrap_handler(binding)
-                    )
-                )
-            )
-            log_api("<= page.expose_function succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.expose_function failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.hide_highlight()))
 
-    def expose_binding(
-        self, name: str, binding: typing.Callable, handle: bool = None
-    ) -> NoneType:
-        """Page.expose_binding
 
-        The method adds a function called `name` on the `window` object of every frame in this page. When called, the function
-        executes `playwrightBinding` in Node.js and returns a Promise which resolves to the return value of
-        `playwrightBinding`. If the `playwrightBinding` returns a Promise, it will be awaited.
-        The first argument of the `playwrightBinding` function contains information about the caller: `{ browserContext: BrowserContext, page: Page, frame: Frame }`.
-        See browser_context.expose_binding(name, playwrightBinding[, options]) for the context-wide version.
+mapping.register(LocatorImpl, Locator)
 
-        **NOTE** Functions installed via `page.expose_binding` survive navigations.
 
-        An example of exposing page URL to all frames in a page:
+class APIResponse(SyncBase):
 
-        An example of passing an element handle:
+    @property
+    def ok(self) -> bool:
+        """APIResponse.ok
 
-        Parameters
-        ----------
-        name : str
-            Name of the function on the window object.
-        binding : Callable
-            Callback function that will be called in the Playwright's context.
-        handle : Optional[bool]
-            Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is supported. When passing by value, multiple arguments are supported.
+        Contains a boolean stating whether the response was successful (status in the range 200-299) or not.
+
+        Returns
+        -------
+        bool
         """
+        return mapping.from_maybe_impl(self._impl_obj.ok)
 
-        try:
-            log_api("=> page.expose_binding started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.exposeBinding(
-                        name=name, binding=self._wrap_handler(binding), handle=handle
-                    )
-                )
-            )
-            log_api("<= page.expose_binding succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.expose_binding failed")
-            raise e
+    @property
+    def url(self) -> str:
+        """APIResponse.url
 
-    def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneType:
-        """Page.set_extra_http_headers
+        Contains the URL of the response.
 
-        The extra HTTP headers will be sent with every request the page initiates.
+        Returns
+        -------
+        str
+        """
+        return mapping.from_maybe_impl(self._impl_obj.url)
 
-        **NOTE** page.set_extra_http_headers does not guarantee the order of headers in the outgoing requests.
+    @property
+    def status(self) -> int:
+        """APIResponse.status
 
-        Parameters
-        ----------
-        headers : Dict[str, str]
-            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
-        """
+        Contains the status code of the response (e.g., 200 for a success).
 
-        try:
-            log_api("=> page.set_extra_http_headers started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.setExtraHTTPHeaders(headers=mapping.to_impl(headers))
-                )
-            )
-            log_api("<= page.set_extra_http_headers succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_extra_http_headers failed")
-            raise e
+        Returns
+        -------
+        int
+        """
+        return mapping.from_maybe_impl(self._impl_obj.status)
 
-    def content(self) -> str:
-        """Page.content
+    @property
+    def status_text(self) -> str:
+        """APIResponse.status_text
 
-        Gets the full HTML contents of the page, including the doctype.
+        Contains the status text of the response (e.g. usually an \"OK\" for a success).
 
         Returns
         -------
         str
         """
+        return mapping.from_maybe_impl(self._impl_obj.status_text)
 
-        try:
-            log_api("=> page.content started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.content()))
-            log_api("<= page.content succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.content failed")
-            raise e
+    @property
+    def headers(self) -> typing.Dict[str, str]:
+        """APIResponse.headers
 
-    def set_content(
-        self,
-        html: str,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-    ) -> NoneType:
-        """Page.set_content
+        An object with all the response HTTP headers associated with this response.
 
-        Parameters
-        ----------
-        html : str
-            HTML markup to assign to the page.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
+        Returns
+        -------
+        Dict[str, str]
         """
+        return mapping.from_maybe_impl(self._impl_obj.headers)
 
-        try:
-            log_api("=> page.set_content started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.setContent(
-                        html=html, timeout=timeout, waitUntil=wait_until
-                    )
-                )
-            )
-            log_api("<= page.set_content succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_content failed")
-            raise e
+    @property
+    def headers_array(self) -> typing.List[NameValue]:
+        """APIResponse.headers_array
 
-    def goto(
-        self,
-        url: str,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        referer: str = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Page.goto
+        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.
 
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-        last redirect.
-        `page.goto` will throw an error if:
+        Returns
+        -------
+        List[{name: str, value: str}]
+        """
+        return mapping.from_impl_list(self._impl_obj.headers_array)
 
-        there's an SSL error (e.g. in case of self-signed certificates).
-        target URL is invalid.
-        the `timeout` is exceeded during navigation.
-        the remote server does not respond or is unreachable.
-        the main resource failed to load.
+    def body(self) -> bytes:
+        """APIResponse.body
 
-        `page.goto` 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().
+        Returns the buffer with response body.
 
-        **NOTE** `page.goto` 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.
+        Returns
+        -------
+        bytes
+        """
 
-        Shortcut for main frame's frame.goto(url[, options])
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.body()))
 
-        Parameters
-        ----------
-        url : str
-            URL to navigate page to. The url should include scheme, e.g. `https://`.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
-        referer : Optional[str]
-            Referer header value. If provided it will take preference over the referer header value set by page.setExtraHTTPHeaders(headers).
+    def text(self) -> str:
+        """APIResponse.text
+
+        Returns the text representation of response body.
 
         Returns
         -------
-        Optional[Response]
+        str
         """
 
-        try:
-            log_api("=> page.goto started")
-            result = mapping.from_impl_nullable(
-                self._sync(
-                    self._impl_obj.goto(
-                        url=url, timeout=timeout, waitUntil=wait_until, referer=referer
-                    )
-                )
-            )
-            log_api("<= page.goto succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.goto failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.text()))
 
-    def reload(
-        self,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Page.reload
+    def json(self) -> typing.Any:
+        """APIResponse.json
 
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-        last redirect.
+        Returns the JSON representation of response body.
 
-        Parameters
-        ----------
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
+        This method will throw if the response body is not parsable via `JSON.parse`.
 
         Returns
         -------
-        Optional[Response]
+        Any
         """
 
-        try:
-            log_api("=> page.reload started")
-            result = mapping.from_impl_nullable(
-                self._sync(self._impl_obj.reload(timeout=timeout, waitUntil=wait_until))
-            )
-            log_api("<= page.reload succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.reload failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.json()))
 
-    def wait_for_load_state(
-        self,
-        state: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> NoneType:
-        """Page.wait_for_load_state
+    def dispose(self) -> None:
+        """APIResponse.dispose
 
-        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.
-        Shortcut for main frame's frame.wait_for_load_state([state, options]).
+        Disposes the body of this response. If not called then the body will stay in memory until the context closes.
+        """
+
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.dispose()))
+
+
+mapping.register(APIResponseImpl, APIResponse)
+
+
+class APIRequestContext(SyncBase):
+
+    @property
+    def tracing(self) -> "Tracing":
+        """APIRequestContext.tracing
+
+        Returns
+        -------
+        Tracing
+        """
+        return mapping.from_impl(self._impl_obj.tracing)
+
+    def dispose(self, *, reason: typing.Optional[str] = None) -> None:
+        """APIRequestContext.dispose
+
+        All responses returned by `a_pi_request_context.get()` and similar methods are stored in the memory, so that
+        you can later call `a_pi_response.body()`.This method discards all its resources, calling any method on
+        disposed `APIRequestContext` will throw an exception.
 
         Parameters
         ----------
-        state : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            Load state to wait for, defaults to `load`. If the state has been already reached while loading current document, the method resolves immediately. Optional.
-             - `'load'` - wait for the `load` event to be fired.
-             - `'domcontentloaded'` - wait for the `DOMContentLoaded` event to be fired.
-             - `'networkidle'` - wait until there are no network connections for at least `500` ms.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        reason : Union[str, None]
+            The reason to be reported to the operations interrupted by the context disposal.
         """
 
-        try:
-            log_api("=> page.wait_for_load_state started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.waitForLoadState(state=state, timeout=timeout)
-                )
-            )
-            log_api("<= page.wait_for_load_state succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_load_state failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.dispose(reason=reason))
+        )
 
-    def wait_for_navigation(
+    def delete(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Page.wait_for_navigation
-
-        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`.
-        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:
-        **NOTE** Usage of the History API to change the URL is
-        considered a navigation.
-        Shortcut for main frame's frame.wait_for_navigation([options]).
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.delete
+
+        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.
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool], NoneType]
-            A glob pattern, regex pattern or predicate receiving URL to match while waiting for the navigation.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Optional[Response]
-        """
-
-        try:
-            log_api("=> page.wait_for_navigation started")
-            result = mapping.from_impl_nullable(
-                self._sync(
-                    self._impl_obj.waitForNavigation(
-                        url=self._wrap_handler(url),
-                        waitUntil=wait_until,
-                        timeout=timeout,
-                    )
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.delete(
+                    url=url,
+                    params=mapping.to_impl(params),
+                    headers=mapping.to_impl(headers),
+                    data=mapping.to_impl(data),
+                    form=mapping.to_impl(form),
+                    multipart=mapping.to_impl(multipart),
+                    timeout=to_milliseconds(timeout),
+                    failOnStatusCode=fail_on_status_code,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                 )
             )
-            log_api("<= page.wait_for_navigation succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_navigation failed")
-            raise e
+        )
 
-    def wait_for_request(
+    def head(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        predicate: typing.Union[typing.Callable[["Request"], bool]] = None,
-        timeout: int = None,
-    ) -> "Request":
-        """Page.wait_for_request
-
-        Returns promise that resolves to the matched request.
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.head
+
+        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.
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool], NoneType]
-            Request URL string, regex or predicate receiving Request object.
-        timeout : Optional[int]
-            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) method.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Request
-        """
-
-        try:
-            log_api("=> page.wait_for_request started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.waitForRequest(
-                        url=self._wrap_handler(url),
-                        predicate=self._wrap_handler(predicate),
-                        timeout=timeout,
-                    )
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.head(
+                    url=url,
+                    params=mapping.to_impl(params),
+                    headers=mapping.to_impl(headers),
+                    data=mapping.to_impl(data),
+                    form=mapping.to_impl(form),
+                    multipart=mapping.to_impl(multipart),
+                    timeout=to_milliseconds(timeout),
+                    failOnStatusCode=fail_on_status_code,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                 )
             )
-            log_api("<= page.wait_for_request succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_request failed")
-            raise e
+        )
 
-    def wait_for_response(
+    def get(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        predicate: typing.Union[typing.Callable[["Response"], bool]] = None,
-        timeout: int = None,
-    ) -> "Response":
-        """Page.wait_for_response
-
-        Returns the matched response.
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.get
+
+        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:
+
+        ```python
+        query_params = {
+          \"isbn\": \"1234\",
+          \"page\": \"23\"
+        }
+        api_request_context.get(\"https://example.com/api/getText\", params=query_params)
+        ```
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool], NoneType]
-            Request URL string, regex or predicate receiving Response object.
-        timeout : Optional[int]
-            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) or page.setDefaultTimeout(timeout) methods.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Response
-        """
-
-        try:
-            log_api("=> page.wait_for_response started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.waitForResponse(
-                        url=self._wrap_handler(url),
-                        predicate=self._wrap_handler(predicate),
-                        timeout=timeout,
-                    )
-                )
-            )
-            log_api("<= page.wait_for_response succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_response failed")
-            raise e
-
-    def wait_for_event(
-        self,
-        event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
-    ) -> typing.Any:
-        """Page.wait_for_event
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.get(
+                    url=url,
+                    params=mapping.to_impl(params),
+                    headers=mapping.to_impl(headers),
+                    data=mapping.to_impl(data),
+                    form=mapping.to_impl(form),
+                    multipart=mapping.to_impl(multipart),
+                    timeout=to_milliseconds(timeout),
+                    failOnStatusCode=fail_on_status_code,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    maxRedirects=max_redirects,
+                    maxRetries=max_retries,
+                )
+            )
+        )
 
-        Returns the event data value.
-        Waits for event to fire and passes its value into the predicate function. Resolves when the predicate returns truthy
-        value. Will throw an error if the page is closed before the event is fired.
+    def patch(
+        self,
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.patch
+
+        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.
 
         Parameters
         ----------
-        event : str
-            Event name, same one would pass into `page.on(event)`.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Any
-        """
-
-        try:
-            log_api("=> page.wait_for_event started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.waitForEvent(
-                        event=event,
-                        predicate=self._wrap_handler(predicate),
-                        timeout=timeout,
-                    )
-                )
-            )
-            log_api("<= page.wait_for_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_event failed")
-            raise e
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.patch(
+                    url=url,
+                    params=mapping.to_impl(params),
+                    headers=mapping.to_impl(headers),
+                    data=mapping.to_impl(data),
+                    form=mapping.to_impl(form),
+                    multipart=mapping.to_impl(multipart),
+                    timeout=to_milliseconds(timeout),
+                    failOnStatusCode=fail_on_status_code,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    maxRedirects=max_redirects,
+                    maxRetries=max_retries,
+                )
+            )
+        )
 
-    def go_back(
+    def put(
         self,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Page.go_back
-
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-        last redirect. If can not go back, resolves to `null`.
-        Navigate to the previous page in history.
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.put
+
+        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.
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Optional[Response]
-        """
-
-        try:
-            log_api("=> page.go_back started")
-            result = mapping.from_impl_nullable(
-                self._sync(self._impl_obj.goBack(timeout=timeout, waitUntil=wait_until))
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.put(
+                    url=url,
+                    params=mapping.to_impl(params),
+                    headers=mapping.to_impl(headers),
+                    data=mapping.to_impl(data),
+                    form=mapping.to_impl(form),
+                    multipart=mapping.to_impl(multipart),
+                    timeout=to_milliseconds(timeout),
+                    failOnStatusCode=fail_on_status_code,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    maxRedirects=max_redirects,
+                    maxRetries=max_retries,
+                )
             )
-            log_api("<= page.go_back succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.go_back failed")
-            raise e
+        )
 
-    def go_forward(
+    def post(
         self,
-        timeout: int = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-    ) -> typing.Union["Response", NoneType]:
-        """Page.go_forward
+        url: str,
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.post
+
+        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:
+
+        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):
+
+        ```python
+        formData = {
+            \"title\": \"Book Title\",
+            \"body\": \"John Doe\",
+        }
+        api_request_context.post(\"https://example.com/api/findBook\", form=formData)
+        ```
 
-        Returns the main resource response. In case of multiple redirects, the navigation will resolve with the response of the
-        last redirect. If can not go forward, resolves to `null`.
-        Navigate to the next page in history.
+        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:
+
+        ```python
+        api_request_context.post(
+          \"https://example.com/api/uploadScript'\",
+          multipart={
+            \"fileField\": {
+              \"name\": \"f.js\",
+              \"mimeType\": \"text/javascript\",
+              \"buffer\": b\"console.log(2022);\",
+            },
+          })
+        ```
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum operation time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultNavigationTimeout(timeout), browserContext.setDefaultTimeout(timeout), page.setDefaultNavigationTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        wait_until : Optional[Literal['domcontentloaded', 'load', 'networkidle']]
-            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'` - consider operation to be finished when there are no network connections for at least `500` ms.
+        url : str
+            Target URL.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
         Returns
         -------
-        Optional[Response]
-        """
-
-        try:
-            log_api("=> page.go_forward started")
-            result = mapping.from_impl_nullable(
-                self._sync(
-                    self._impl_obj.goForward(timeout=timeout, waitUntil=wait_until)
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.post(
+                    url=url,
+                    params=mapping.to_impl(params),
+                    headers=mapping.to_impl(headers),
+                    data=mapping.to_impl(data),
+                    form=mapping.to_impl(form),
+                    multipart=mapping.to_impl(multipart),
+                    timeout=to_milliseconds(timeout),
+                    failOnStatusCode=fail_on_status_code,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                 )
             )
-            log_api("<= page.go_forward succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.go_forward failed")
-            raise e
+        )
 
-    def emulate_media(
+    def fetch(
         self,
-        media: Literal["print", "screen"] = None,
-        color_scheme: Literal["dark", "light", "no-preference"] = None,
-    ) -> NoneType:
-        """Page.emulate_media
-
+        url_or_request: typing.Union[str, "Request"],
+        *,
+        params: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], str]
+        ] = None,
+        method: typing.Optional[str] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        data: typing.Optional[typing.Union[typing.Any, bytes, str]] = None,
+        form: typing.Optional[
+            typing.Union[typing.Dict[str, typing.Union[str, float, bool]], "FormData"]
+        ] = None,
+        multipart: typing.Optional[
+            typing.Union[
+                typing.Dict[str, typing.Union[bytes, bool, float, str, FilePayload]],
+                "FormData",
+            ]
+        ] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+        max_retries: typing.Optional[int] = None,
+    ) -> "APIResponse":
+        """APIRequestContext.fetch
+
+        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:
+
+        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:
+
+        ```python
+        api_request_context.fetch(
+          \"https://example.com/api/uploadScript\",  method=\"post\",
+          multipart={
+            \"fileField\": {
+              \"name\": \"f.js\",
+              \"mimeType\": \"text/javascript\",
+              \"buffer\": b\"console.log(2022);\",
+            },
+          })
+        ```
 
         Parameters
         ----------
-        media : Optional[Literal['print', 'screen']]
-            Changes the CSS media type of the page. The only allowed values are `'screen'`, `'print'` and `null`. Passing `null` disables CSS media emulation. Omitting `media` or passing `undefined` does not change the emulated value.
-        color_scheme : Optional[Literal['dark', 'light', 'no-preference']]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. Passing `null` disables color scheme emulation. Omitting `colorScheme` or passing `undefined` does not change the emulated value.
-        """
+        url_or_request : Union[Request, str]
+            Target URL or Request to get all parameters from.
+        params : Union[Dict[str, Union[bool, float, str]], str, None]
+            Query parameters to be sent with the URL.
+        method : Union[str, None]
+            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.
+        headers : Union[Dict[str, str], None]
+            Allows to set HTTP headers. These headers will apply to the fetched request as well as any redirects initiated by
+            it.
+        data : Union[Any, bytes, str, None]
+            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.
+        form : Union[Dict[str, Union[bool, float, str]], FormData, None]
+            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. Use `FormData` to send multiple values for the same
+            field.
+        multipart : Union[Dict[str, Union[bool, bytes, float, str, {name: str, mimeType: str, buffer: bytes}]], FormData, None]
+            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 as file-like object containing file name, mime-type and its content.
+            Use `FormData` to send multiple files in the same field.
+        timeout : Union[float, None]
+            Request timeout in milliseconds. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        max_redirects : Union[int, None]
+            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.
+        max_retries : Union[int, None]
+            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.
 
-        try:
-            log_api("=> page.emulate_media started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.emulateMedia(media=media, colorScheme=color_scheme)
+        Returns
+        -------
+        APIResponse
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.fetch(
+                    urlOrRequest=url_or_request,
+                    params=mapping.to_impl(params),
+                    method=method,
+                    headers=mapping.to_impl(headers),
+                    data=mapping.to_impl(data),
+                    form=mapping.to_impl(form),
+                    multipart=mapping.to_impl(multipart),
+                    timeout=to_milliseconds(timeout),
+                    failOnStatusCode=fail_on_status_code,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    maxRedirects=max_redirects,
+                    maxRetries=max_retries,
                 )
             )
-            log_api("<= page.emulate_media succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.emulate_media failed")
-            raise e
+        )
 
-    def set_viewport_size(self, width: int, height: int) -> NoneType:
-        """Page.set_viewport_size
+    def storage_state(
+        self,
+        *,
+        path: typing.Optional[typing.Union[pathlib.Path, str]] = None,
+        indexed_db: typing.Optional[bool] = None,
+    ) -> StorageState:
+        """APIRequestContext.storage_state
 
-        In the case of multiple pages in a single browser, each page can have its own viewport size. However,
-        browser.new_context([options]) allows to set viewport size (and more) for all pages in the context at once.
-        `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.
+        Returns storage state for this request context, contains current cookies and local storage snapshot if it was
+        passed to the constructor.
 
         Parameters
         ----------
-        width : int
-            page width in pixels. **required**
-        height : int
-            page height in pixels. **required**
-        """
-
-        try:
-            log_api("=> page.set_viewport_size started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.setViewportSize(width=width, height=height))
-            )
-            log_api("<= page.set_viewport_size succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_viewport_size failed")
-            raise e
-
-    def viewport_size(self) -> typing.Union[typing.Tuple[int, int], NoneType]:
-        """Page.viewport_size
+        path : Union[pathlib.Path, str, None]
+            The file path to save the storage state to. If `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.
+        indexed_db : Union[bool, None]
+            Set to `true` to include IndexedDB in the storage state snapshot.
 
         Returns
         -------
-        Optional[typing.Tuple[int, int]]
+        {cookies: List[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: List[{origin: str, localStorage: List[{name: str, value: str}]}]}
         """
 
-        try:
-            log_api("=> page.viewport_size started")
-            result = mapping.from_maybe_impl(self._impl_obj.viewportSize())
-            log_api("<= page.viewport_size succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.viewport_size failed")
-            raise e
-
-    def bring_to_front(self) -> NoneType:
-        """Page.bring_to_front
-
-        Brings page to front (activates tab).
-        """
+        return mapping.from_impl(
+            self._sync(self._impl_obj.storage_state(path=path, indexedDB=indexed_db))
+        )
 
-        try:
-            log_api("=> page.bring_to_front started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.bringToFront()))
-            log_api("<= page.bring_to_front succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.bring_to_front failed")
-            raise e
 
-    def add_init_script(
-        self, source: str = None, path: typing.Union[str, pathlib.Path] = None
-    ) -> NoneType:
-        """Page.add_init_script
+mapping.register(APIRequestContextImpl, APIRequestContext)
 
-        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.
+class APIRequest(SyncBase):
 
-        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`.
-        An example of overriding `Math.random` before the page loads:
+    def new_context(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        extra_http_headers: typing.Optional[typing.Dict[str, str]] = None,
+        http_credentials: typing.Optional[HttpCredentials] = None,
+        ignore_https_errors: typing.Optional[bool] = None,
+        proxy: typing.Optional[ProxySettings] = None,
+        user_agent: typing.Optional[str] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        storage_state: typing.Optional[
+            typing.Union[StorageState, str, pathlib.Path]
+        ] = None,
+        client_certificates: typing.Optional[typing.List[ClientCertificate]] = None,
+        fail_on_status_code: typing.Optional[bool] = None,
+        max_redirects: typing.Optional[int] = None,
+    ) -> "APIRequestContext":
+        """APIRequest.new_context
 
-        **NOTE** The order of evaluation of multiple scripts installed via browser_context.add_init_script(script[, arg]) and
-        page.add_init_script(script[, arg]) is not defined.
+        Creates new instances of `APIRequestContext`.
 
         Parameters
         ----------
-        source : Optional[str]
-            Script to be evaluated in the page.
-        """
+        base_url : Union[str, None]
+            Methods like `a_pi_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`
+        extra_http_headers : Union[Dict[str, str], None]
+            An object containing additional HTTP headers to be sent with every request. Defaults to none.
+        http_credentials : Union[{username: str, password: str, origin: Union[str, None], send: Union["always", "unauthorized", None]}, None]
+            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.
+        ignore_https_errors : Union[bool, None]
+            Whether to ignore HTTPS errors when sending network requests. Defaults to `false`.
+        proxy : Union[{server: str, bypass: Union[str, None], username: Union[str, None], password: Union[str, None]}, None]
+            Network proxy settings.
+        user_agent : Union[str, None]
+            Specific user agent to use in this context.
+        timeout : Union[float, None]
+            Maximum time in milliseconds to wait for the response. Defaults to `30000` (30 seconds). Pass `0` to disable
+            timeout.
+        storage_state : Union[pathlib.Path, str, {cookies: Sequence[{name: str, value: str, domain: str, path: str, expires: float, httpOnly: bool, secure: bool, sameSite: Union["Lax", "None", "Strict"]}], origins: Sequence[{origin: str, localStorage: Sequence[{name: str, value: str}]}]}, None]
+            Populates context with given storage state. This option can be used to initialize context with logged-in
+            information obtained via `browser_context.storage_state()` or `a_pi_request_context.storage_state()`.
+            Either a path to the file with saved storage, or the value returned by one of
+            `browser_context.storage_state()` or `a_pi_request_context.storage_state()` methods.
+        client_certificates : Union[Sequence[{origin: str, certPath: Union[pathlib.Path, str, None], cert: Union[bytes, None], keyPath: Union[pathlib.Path, str, None], key: Union[bytes, None], pfxPath: Union[pathlib.Path, str, None], pfx: Union[bytes, None], passphrase: Union[str, None]}], None]
+            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.
+
+            Client certificate authentication is only active when at least one client certificate is provided. If you want to
+            reject all client certificates sent by the server, you need to provide a client certificate with an `origin` that
+            does not match any of the domains you plan to visit.
+
+            **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`.
+
+        fail_on_status_code : Union[bool, None]
+            Whether to throw on response codes other than 2xx and 3xx. By default response object is returned for all status
+            codes.
+        max_redirects : Union[int, None]
+            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. This can be overwritten for each request
+            individually.
 
-        try:
-            log_api("=> page.add_init_script started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.addInitScript(source=source, path=path))
+        Returns
+        -------
+        APIRequestContext
+        """
+
+        return mapping.from_impl(
+            self._sync(
+                self._impl_obj.new_context(
+                    baseURL=base_url,
+                    extraHTTPHeaders=mapping.to_impl(extra_http_headers),
+                    httpCredentials=http_credentials,
+                    ignoreHTTPSErrors=ignore_https_errors,
+                    proxy=proxy,
+                    userAgent=user_agent,
+                    timeout=to_milliseconds(timeout),
+                    storageState=storage_state,
+                    clientCertificates=client_certificates,
+                    failOnStatusCode=fail_on_status_code,
+                    maxRedirects=max_redirects,
+                )
             )
-            log_api("<= page.add_init_script succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.add_init_script failed")
-            raise e
+        )
 
-    def route(
+
+mapping.register(APIRequestImpl, APIRequest)
+
+
+class PageAssertions(SyncBase):
+
+    def to_have_title(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]],
-        handler: typing.Union[
-            typing.Callable[["Route"], typing.Any],
-            typing.Callable[["Route", "Request"], typing.Any],
-        ],
-    ) -> NoneType:
-        """Page.route
+        title_or_reg_exp: typing.Union[typing.Pattern[str], str],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """PageAssertions.to_have_title
 
-        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.
+        Ensures the page has the given title.
 
-        **NOTE** The handler will only be called for the first url if the response is a redirect.
+        **Usage**
 
-        An example of a naïve handler that aborts all image requests:
-        or the same snippet using a regex pattern instead:
-        Page routes take precedence over browser context routes (set up with browser_context.route(url, handler)) when request matches
-        both handlers.
+        ```py
+        import re
+        from playwright.sync_api import expect
 
-        **NOTE** Enabling routing disables http cache.
+        # ...
+        expect(page).to_have_title(re.compile(r\".*checkout\"))
+        ```
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool]]
-            A glob pattern, regex pattern or predicate receiving URL to match while routing.
-        handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any]]
-            handler function to route the request.
+        title_or_reg_exp : Union[Pattern[str], str]
+            Expected title or RegExp.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.route started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.route(
-                        url=self._wrap_handler(url), handler=self._wrap_handler(handler)
-                    )
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_title(
+                    titleOrRegExp=title_or_reg_exp, timeout=to_milliseconds(timeout)
                 )
             )
-            log_api("<= page.route succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.route failed")
-            raise e
+        )
 
-    def unroute(
+    def not_to_have_title(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]],
-        handler: typing.Union[
-            typing.Callable[["Route"], typing.Any],
-            typing.Callable[["Route", "Request"], typing.Any],
-        ] = None,
-    ) -> NoneType:
-        """Page.unroute
+        title_or_reg_exp: typing.Union[typing.Pattern[str], str],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """PageAssertions.not_to_have_title
 
-        Removes a route created with page.route(url, handler). When `handler` is not specified, removes all routes for the `url`.
+        The opposite of `page_assertions.to_have_title()`.
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool]]
-            A glob pattern, regex pattern or predicate receiving URL to match while routing.
-        handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any], NoneType]
-            Optional handler function to route the request.
+        title_or_reg_exp : Union[Pattern[str], str]
+            Expected title or RegExp.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.unroute started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.unroute(
-                        url=self._wrap_handler(url), handler=self._wrap_handler(handler)
-                    )
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_title(
+                    titleOrRegExp=title_or_reg_exp, timeout=to_milliseconds(timeout)
                 )
             )
-            log_api("<= page.unroute succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.unroute failed")
-            raise e
+        )
 
-    def screenshot(
+    def to_have_url(
         self,
-        timeout: int = None,
-        type: Literal["jpeg", "png"] = None,
-        path: typing.Union[str, pathlib.Path] = None,
-        quality: int = None,
-        omit_background: bool = None,
-        full_page: bool = None,
-        clip: "FloatRect" = None,
-    ) -> bytes:
-        """Page.screenshot
+        url_or_reg_exp: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """PageAssertions.to_have_url
 
-        Returns the buffer with the captured screenshot.
+        Ensures the page is navigated to the given URL.
+
+        **Usage**
+
+        ```py
+        import re
+        from playwright.sync_api import expect
 
-        **NOTE** Screenshots take at least 1/6 second on Chromium OS X and Chromium Windows. See https://crbug.com/741689 for
-        discussion.
+        # ...
+        expect(page).to_have_url(re.compile(\".*checkout\"))
+        ```
 
         Parameters
         ----------
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        type : Optional[Literal['jpeg', 'png']]
-            Specify screenshot type, defaults to `png`.
-        path : Union[str, pathlib.Path, NoneType]
-            The file path to save the image to. The screenshot type will be inferred from file extension. If `path` is a relative path, then it is resolved relative to current working directory. If no path is provided, the image won't be saved to the disk.
-        quality : Optional[int]
-            The quality of the image, between 0-100. Not applicable to `png` images.
-        omit_background : Optional[bool]
-            Hides default white background and allows capturing screenshots with transparency. Not applicable to `jpeg` images. Defaults to `false`.
-        full_page : Optional[bool]
-            When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Defaults to `false`.
-        clip : Optional[{"x": float, "y": float, "width": float, "height": float}]
-            An object which specifies clipping of the resulting image. Should have the following fields:
+        url_or_reg_exp : Union[Pattern[str], str]
+            Expected URL string or RegExp.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression parameter if specified. A provided predicate ignores this flag.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_url(
+                    urlOrRegExp=url_or_reg_exp,
+                    timeout=to_milliseconds(timeout),
+                    ignoreCase=ignore_case,
+                )
+            )
+        )
 
-        Returns
-        -------
-        bytes
-        """
+    def not_to_have_url(
+        self,
+        url_or_reg_exp: typing.Union[typing.Pattern[str], str],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """PageAssertions.not_to_have_url
 
-        try:
-            log_api("=> page.screenshot started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.screenshot(
-                        timeout=timeout,
-                        type=type,
-                        path=path,
-                        quality=quality,
-                        omitBackground=omit_background,
-                        fullPage=full_page,
-                        clip=clip,
-                    )
-                )
-            )
-            log_api("<= page.screenshot succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.screenshot failed")
-            raise e
+        The opposite of `page_assertions.to_have_url()`.
 
-    def title(self) -> str:
-        """Page.title
+        Parameters
+        ----------
+        url_or_reg_exp : Union[Pattern[str], str]
+            Expected URL string or RegExp.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_url(
+                    urlOrRegExp=url_or_reg_exp,
+                    timeout=to_milliseconds(timeout),
+                    ignoreCase=ignore_case,
+                )
+            )
+        )
 
-        Returns the page's title. Shortcut for main frame's frame.title().
+    def to_match_aria_snapshot(
+        self,
+        expected: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """PageAssertions.to_match_aria_snapshot
+
+        Asserts that the page body matches the given [accessibility snapshot](https://playwright.dev/python/docs/aria-snapshots).
+
+        **Usage**
+
+        ```py
+        page.goto(\"https://demo.playwright.dev/todomvc/\")
+        expect(page).to_match_aria_snapshot('''
+          - heading \"todos\"
+          - textbox \"What needs to be done?\"
+        ''')
+        ```
 
-        Returns
-        -------
-        str
+        Parameters
+        ----------
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.title started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.title()))
-            log_api("<= page.title succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.title failed")
-            raise e
-
-    def close(self, run_before_unload: bool = None) -> NoneType:
-        """Page.close
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_match_aria_snapshot(
+                    expected=expected, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-        If `runBeforeUnload` is `false` the result will resolve only after the page has been closed. If `runBeforeUnload` is
-        `true` the method will **not** wait for the page to close. By default, `page.close()` **does not** run beforeunload
-        handlers.
+    def not_to_match_aria_snapshot(
+        self,
+        expected: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """PageAssertions.not_to_match_aria_snapshot
 
-        **NOTE** if `runBeforeUnload` is passed as true, a `beforeunload` dialog might be summoned
-        and should be handled manually via page.on('dialog') event.
+        The opposite of `page_assertions.to_match_aria_snapshot()`.
 
         Parameters
         ----------
-        run_before_unload : Optional[bool]
-            Defaults to `false`. Whether to run the before unload page handlers.
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.close started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.close(runBeforeUnload=run_before_unload))
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_match_aria_snapshot(
+                    expected=expected, timeout=to_milliseconds(timeout)
+                )
             )
-            log_api("<= page.close succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.close failed")
-            raise e
+        )
 
-    def is_closed(self) -> bool:
-        """Page.is_closed
 
-        Indicates that the page has been closed.
+mapping.register(PageAssertionsImpl, PageAssertions)
 
-        Returns
-        -------
-        bool
-        """
 
-        try:
-            log_api("=> page.is_closed started")
-            result = mapping.from_maybe_impl(self._impl_obj.isClosed())
-            log_api("<= page.is_closed succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.is_closed failed")
-            raise e
+class LocatorAssertions(SyncBase):
 
-    def click(
+    def to_contain_text(
         self,
-        selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        click_count: int = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.click
-
-        This method clicks an element matching `selector` by performing the following steps:
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
+        ],
+        *,
+        use_inner_text: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """LocatorAssertions.to_contain_text
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        Ensures the `Locator` points to an element that contains the given text. All nested elements will be considered
+        when computing the text content of the element. You can use regular expressions for the value as well.
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
-        Shortcut for main frame's frame.click(selector[, options]).
+        **Details**
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
-            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
-            Defaults to `left`.
-        click_count : Optional[int]
-            defaults to 1. See UIEvent.detail.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        When `expected` parameter is a string, Playwright will normalize whitespaces and line breaks both in the actual
+        text and in the expected string before matching. When regular expression is used, the actual text is matched as is.
 
-        try:
-            log_api("=> page.click started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.click(
-                        selector=selector,
-                        modifiers=modifiers,
-                        position=position,
-                        delay=delay,
-                        button=button,
-                        clickCount=click_count,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= page.click succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.click failed")
-            raise e
+        **Usage**
 
-    def dblclick(
-        self,
-        selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        delay: int = None,
-        button: Literal["left", "middle", "right"] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.dblclick
+        ```py
+        import re
+        from playwright.sync_api import expect
 
-        This method double clicks an element matching `selector` by performing the following steps:
+        locator = page.locator('.title')
+        expect(locator).to_contain_text(\"substring\")
+        expect(locator).to_contain_text(re.compile(r\"\\d messages\"))
+        ```
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to double click in the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if the first click of the `dblclick()` triggers a navigation event, this method will reject.
+        If you pass an array as an expected value, the expectations are:
+        1. Locator resolves to a list of elements.
+        1. Elements from a **subset** of this list contain text from the expected array, respectively.
+        1. The matching subset of elements has the same order as the expected array.
+        1. Each text value from the expected array is matched by some element from the list.
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        For example, consider the following list:
 
-        **NOTE** `page.dblclick()` dispatches two `click` events and a single `dblclick` event.
+        ```html
+        <ul>
+          <li>Item Text 1</li>
+          <li>Item Text 2</li>
+          <li>Item Text 3</li>
+        </ul>
+        ```
 
-        Shortcut for main frame's frame.dblclick(selector[, options]).
+        Let's see how we can use the assertion:
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        delay : Optional[int]
-            Time to wait between `mousedown` and `mouseup` in milliseconds. Defaults to 0.
-        button : Optional[Literal['left', 'middle', 'right']]
-            Defaults to `left`.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        ```py
+        from playwright.sync_api import expect
 
-        try:
-            log_api("=> page.dblclick started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.dblclick(
-                        selector=selector,
-                        modifiers=modifiers,
-                        position=position,
-                        delay=delay,
-                        button=button,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= page.dblclick succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.dblclick failed")
-            raise e
+        # ✓ Contains the right items in the right order
+        expect(page.locator(\"ul > li\")).to_contain_text([\"Text 1\", \"Text 3\"])
 
-    def tap(
-        self,
-        selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.tap
+        # ✖ Wrong order
+        expect(page.locator(\"ul > li\")).to_contain_text([\"Text 3\", \"Text 2\"])
 
-        This method taps an element matching `selector` by performing the following steps:
+        # ✖ No item contains this text
+        expect(page.locator(\"ul > li\")).to_contain_text([\"Some 33\"])
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.touchscreen to tap the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        # ✖ Locator points to the outer list element, not to the list items
+        expect(page.locator(\"ul\")).to_contain_text([\"Text 3\"])
+        ```
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
+        Parameters
+        ----------
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected substring or RegExp or a list of those.
+        use_inner_text : Union[bool, None]
+            Whether to use `element.innerText` instead of `element.textContent` when retrieving DOM node text.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_contain_text(
+                    expected=mapping.to_impl(expected),
+                    useInnerText=use_inner_text,
+                    timeout=to_milliseconds(timeout),
+                    ignoreCase=ignore_case,
+                )
+            )
+        )
 
-        **NOTE** `page.tap()` requires that the `hasTouch` option of the browser context be set to true.
+    def not_to_contain_text(
+        self,
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
+        ],
+        *,
+        use_inner_text: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_contain_text
 
-        Shortcut for main frame's frame.tap(selector[, options]).
+        The opposite of `locator_assertions.to_contain_text()`.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> page.tap started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.tap(
-                        selector=selector,
-                        modifiers=modifiers,
-                        position=position,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= page.tap succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.tap failed")
-            raise e
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected substring or RegExp or a list of those.
+        use_inner_text : Union[bool, None]
+            Whether to use `element.innerText` instead of `element.textContent` when retrieving DOM node text.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_contain_text(
+                    expected=mapping.to_impl(expected),
+                    useInnerText=use_inner_text,
+                    timeout=to_milliseconds(timeout),
+                    ignoreCase=ignore_case,
+                )
+            )
+        )
 
-    def fill(
-        self, selector: str, value: str, timeout: int = None, no_wait_after: bool = None
-    ) -> NoneType:
-        """Page.fill
+    def to_have_attribute(
+        self,
+        name: str,
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_attribute
 
-        This method waits for an element matching `selector`, waits for actionability checks, focuses the
-        element, fills it and triggers an `input` event after filling. If the element matching `selector` is not an `<input>`,
-        `<textarea>` or `[contenteditable]` element, this method throws an error. Note that you can pass an empty string to
-        clear the input field.
-        To send fine-grained keyboard events, use page.type(selector, text[, options]).
-        Shortcut for main frame's frame.fill(selector, value[, options])
+        Ensures the `Locator` points to an element with given attribute.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        value : str
-            Value to fill for the `<input>`, `<textarea>` or `[contenteditable]` element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        **Usage**
 
-        try:
-            log_api("=> page.fill started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.fill(
-                        selector=selector,
-                        value=value,
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= page.fill succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.fill failed")
-            raise e
-
-    def focus(self, selector: str, timeout: int = None) -> NoneType:
-        """Page.focus
+        ```py
+        from playwright.sync_api import expect
 
-        This method fetches an element with `selector` and focuses it. If there's no element matching `selector`, the method
-        waits until a matching element appears in the DOM.
-        Shortcut for main frame's frame.focus(selector[, options]).
+        locator = page.locator(\"input\")
+        expect(locator).to_have_attribute(\"type\", \"text\")
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        """
-
-        try:
-            log_api("=> page.focus started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.focus(selector=selector, timeout=timeout))
+        name : str
+            Attribute name.
+        value : Union[Pattern[str], str]
+            Expected attribute value.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_attribute(
+                    name=name,
+                    value=value,
+                    ignoreCase=ignore_case,
+                    timeout=to_milliseconds(timeout),
+                )
             )
-            log_api("<= page.focus succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.focus failed")
-            raise e
+        )
 
-    def text_content(
-        self, selector: str, timeout: int = None
-    ) -> typing.Union[str, NoneType]:
-        """Page.text_content
+    def not_to_have_attribute(
+        self,
+        name: str,
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_attribute
 
-        Returns `element.textContent`.
+        The opposite of `locator_assertions.to_have_attribute()`.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-
-        Returns
-        -------
-        Optional[str]
-        """
-
-        try:
-            log_api("=> page.text_content started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.textContent(selector=selector, timeout=timeout)
+        name : str
+            Attribute name.
+        value : Union[Pattern[str], str]
+            Expected attribute value.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_attribute(
+                    name=name,
+                    value=value,
+                    ignoreCase=ignore_case,
+                    timeout=to_milliseconds(timeout),
                 )
             )
-            log_api("<= page.text_content succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.text_content failed")
-            raise e
+        )
 
-    def inner_text(self, selector: str, timeout: int = None) -> str:
-        """Page.inner_text
+    def to_have_class(
+        self,
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_class
 
-        Returns `element.innerText`.
+        Ensures the `Locator` points to an element with given CSS classes. When a string is provided, it must fully match
+        the element's `class` attribute. To match individual classes use `locator_assertions.to_contain_class()`.
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
+        **Usage**
 
-        Returns
-        -------
-        str
-        """
+        ```html
+        <div class='middle selected row' id='component'></div>
+        ```
 
-        try:
-            log_api("=> page.inner_text started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.innerText(selector=selector, timeout=timeout))
-            )
-            log_api("<= page.inner_text succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.inner_text failed")
-            raise e
+        ```py
+        from playwright.sync_api import expect
 
-    def inner_html(self, selector: str, timeout: int = None) -> str:
-        """Page.inner_html
+        locator = page.locator(\"#component\")
+        expect(locator).to_have_class(\"middle selected row\")
+        expect(locator).to_have_class(re.compile(r\"(^|\\\\s)selected(\\\\s|$)\"))
+        ```
 
-        Returns `element.innerHTML`.
+        When an array is passed, the method asserts that the list of elements located matches the corresponding list of
+        expected class values. Each element's class attribute is matched against the corresponding string or regular
+        expression in the array:
+
+        ```py
+        from playwright.sync_api import expect
+
+        locator = page.locator(\".list > .component\")
+        expect(locator).to_have_class([\"component\", \"component selected\", \"component\"])
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-
-        Returns
-        -------
-        str
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected class or RegExp or a list of those.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.inner_html started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.innerHTML(selector=selector, timeout=timeout))
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_class(
+                    expected=mapping.to_impl(expected), timeout=to_milliseconds(timeout)
+                )
             )
-            log_api("<= page.inner_html succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.inner_html failed")
-            raise e
+        )
 
-    def get_attribute(
-        self, selector: str, name: str, timeout: int = None
-    ) -> typing.Union[str, NoneType]:
-        """Page.get_attribute
+    def not_to_have_class(
+        self,
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_class
 
-        Returns element attribute value.
+        The opposite of `locator_assertions.to_have_class()`.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        name : str
-            Attribute name to get the value for.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-
-        Returns
-        -------
-        Optional[str]
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected class or RegExp or a list of those.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.get_attribute started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.getAttribute(
-                        selector=selector, name=name, timeout=timeout
-                    )
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_class(
+                    expected=mapping.to_impl(expected), timeout=to_milliseconds(timeout)
                 )
             )
-            log_api("<= page.get_attribute succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.get_attribute failed")
-            raise e
+        )
 
-    def hover(
+    def to_contain_class(
         self,
-        selector: str,
-        modifiers: typing.Union[
-            typing.List[Literal["Alt", "Control", "Meta", "Shift"]]
-        ] = None,
-        position: typing.Union[typing.Tuple[float, float]] = None,
-        timeout: int = None,
-        force: bool = None,
-    ) -> NoneType:
-        """Page.hover
+        expected: typing.Union[typing.Sequence[str], str],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_contain_class
 
-        This method hovers over an element matching `selector` by performing the following steps:
+        Ensures the `Locator` points to an element with given CSS classes. All classes from the asserted value, separated
+        by spaces, must be present in the
+        [Element.classList](https://developer.mozilla.org/en-US/docs/Web/API/Element/classList) in any order.
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to hover over the center of the element, or the specified `position`.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
+        **Usage**
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
-        Shortcut for main frame's frame.hover(selector[, options]).
+        ```html
+        <div class='middle selected row' id='component'></div>
+        ```
 
-        Parameters
-        ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        modifiers : Optional[List[Literal['Alt', 'Control', 'Meta', 'Shift']]]
-            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.
-        position : Optional[typing.Tuple[float, float]]
-            A point to use relative to the top-left corner of element padding box. If not specified, uses some visible point of the element.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        """
+        ```py
+        from playwright.sync_api import expect
 
-        try:
-            log_api("=> page.hover started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.hover(
-                        selector=selector,
-                        modifiers=modifiers,
-                        position=position,
-                        timeout=timeout,
-                        force=force,
-                    )
-                )
-            )
-            log_api("<= page.hover succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.hover failed")
-            raise e
+        locator = page.locator(\"#component\")
+        expect(locator).to_contain_class(\"middle selected row\")
+        expect(locator).to_contain_class(\"selected\")
+        expect(locator).to_contain_class(\"row middle\")
+        ```
 
-    def select_option(
-        self,
-        selector: str,
-        value: typing.Union[str, typing.List[str]] = None,
-        index: typing.Union[int, typing.List[int]] = None,
-        label: typing.Union[str, typing.List[str]] = None,
-        element: typing.Union["ElementHandle", typing.List["ElementHandle"]] = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> typing.List[str]:
-        """Page.select_option
+        When an array is passed, the method asserts that the list of elements located matches the corresponding list of
+        expected class lists. Each element's class attribute is matched against the corresponding class in the array:
 
-        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. If there's no `<select>` element
-        matching `selector`, the method throws an error.
+        ```html
+        <div class='list'>
+          <div class='component inactive'></div>
+          <div class='component active'></div>
+          <div class='component inactive'></div>
+        </div>
+        ```
+
+        ```py
+        from playwright.sync_api import expect
 
-        Shortcut for main frame's frame.select_option(selector, values[, options])
+        locator = page.locator(\".list > .component\")
+        await expect(locator).to_contain_class([\"inactive\", \"active\", \"inactive\"])
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
-
-        Returns
-        -------
-        List[str]
-        """
-
-        try:
-            log_api("=> page.select_option started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.selectOption(
-                        selector=selector,
-                        value=value,
-                        index=index,
-                        label=label,
-                        element=mapping.to_impl(element),
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= page.select_option succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.select_option failed")
-            raise e
+        expected : Union[Sequence[str], str]
+            A string containing expected class names, separated by spaces, or a list of such strings to assert multiple
+            elements.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_contain_class(
+                    expected=mapping.to_impl(expected), timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def set_input_files(
+    def not_to_contain_class(
         self,
-        selector: str,
-        files: typing.Union[
-            str, "FilePayload", typing.List[str], typing.List["FilePayload"]
-        ],
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.set_input_files
+        expected: typing.Union[typing.Sequence[str], str],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_contain_class
 
-        This method expects `selector` to point to an input
-        element.
-        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.
+        The opposite of `locator_assertions.to_contain_class()`.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        files : Union[str, Dict, List[str], List[Dict]]
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
+        expected : Union[Sequence[str], str]
+            Expected class or RegExp or a list of those.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.set_input_files started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.setInputFiles(
-                        selector=selector,
-                        files=files,
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= page.set_input_files succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.set_input_files failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_contain_class(
+                    expected=mapping.to_impl(expected), timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def type(
+    def to_have_count(
         self,
-        selector: str,
-        text: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.type
+        count: int,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_count
 
-        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]).
-        To press a special key, like `Control` or `ArrowDown`, use keyboard.press(key[, options]).
-        Shortcut for main frame's frame.type(selector, text[, options]).
+        Ensures the `Locator` resolves to an exact number of DOM nodes.
+
+        **Usage**
+
+        ```py
+        from playwright.sync_api import expect
+
+        locator = page.locator(\"list > .component\")
+        expect(locator).to_have_count(3)
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        text : str
-            A text to type into a focused element.
-        delay : Optional[int]
-            Time to wait between key presses in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
+        count : int
+            Expected count.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.type started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.type(
-                        selector=selector,
-                        text=text,
-                        delay=delay,
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= page.type succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.type failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_count(
+                    count=count, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def press(
+    def not_to_have_count(
         self,
-        selector: str,
-        key: str,
-        delay: int = None,
-        timeout: int = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.press
+        count: int,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_count
 
-        Focuses the element, and then uses keyboard.down(key) and keyboard.up(key).
-        `key` can specify the intended keyboardEvent.key
-        value or a single character to generate the text for. A superset of the `key` values can be found
-        here. 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 suported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
-        Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
-        If `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"` or `key: "Control+Shift+T"` are supported as well. When speficied with the
-        modifier, modifier is pressed and being held while the subsequent key is being pressed.
+        The opposite of `locator_assertions.to_have_count()`.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        key : str
-            Name of the key to press or a character to generate, such as `ArrowLeft` or `a`.
-        delay : Optional[int]
-            Time to wait between `keydown` and `keyup` in milliseconds. Defaults to 0.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        no_wait_after : Optional[bool]
-            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`.
+        count : int
+            Expected count.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.press started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.press(
-                        selector=selector,
-                        key=key,
-                        delay=delay,
-                        timeout=timeout,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= page.press succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.press failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_count(
+                    count=count, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def check(
+    def to_have_css(
         self,
-        selector: str,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.check
+        name: str,
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        pseudo: typing.Optional[Literal["after", "before"]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_css
 
-        This method checks an element matching `selector` by performing the following steps:
+        Ensures the `Locator` resolves to an element with the given computed CSS style.
 
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already checked, this method returns immediately.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now checked. If not, this method rejects.
+        **Usage**
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
-        Shortcut for main frame's frame.check(selector[, options]).
+        ```py
+        from playwright.sync_api import expect
+
+        locator = page.get_by_role(\"button\")
+        expect(locator).to_have_css(\"display\", \"flex\")
+        ```
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
-
-        try:
-            log_api("=> page.check started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.check(
-                        selector=selector,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= page.check succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.check failed")
-            raise e
+        name : str
+            CSS property name.
+        value : Union[Pattern[str], str]
+            CSS property value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        pseudo : Union["after", "before", None]
+            Pseudo-element to read computed styles from.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_css(
+                    name=name,
+                    value=value,
+                    timeout=to_milliseconds(timeout),
+                    pseudo=pseudo,
+                )
+            )
+        )
 
-    def uncheck(
+    def not_to_have_css(
         self,
-        selector: str,
-        timeout: int = None,
-        force: bool = None,
-        no_wait_after: bool = None,
-    ) -> NoneType:
-        """Page.uncheck
-
-        This method unchecks an element matching `selector` by performing the following steps:
-
-        Find an element match matching `selector`. If there is none, wait until a matching element is attached to the DOM.
-        Ensure that matched element is a checkbox or a radio input. If not, this method rejects. If the element is already unchecked, this method returns immediately.
-        Wait for actionability checks on the matched element, unless `force` option is set. If the element is detached during the checks, the whole action is retried.
-        Scroll the element into view if needed.
-        Use page.mouse to click in the center of the element.
-        Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-        Ensure that the element is now unchecked. If not, this method rejects.
+        name: str,
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_css
 
-        When all steps combined have not finished during the specified `timeout`, this method rejects with a TimeoutError.
-        Passing zero timeout disables this.
-        Shortcut for main frame's frame.uncheck(selector[, options]).
+        The opposite of `locator_assertions.to_have_css()`.
 
         Parameters
         ----------
-        selector : str
-            A selector to search for element. If there are multiple elements satisfying the selector, the first will be used. See working with selectors for more details.
-        timeout : Optional[int]
-            Maximum time in milliseconds, defaults to 30 seconds, pass `0` to disable timeout. The default value can be changed by using the browserContext.setDefaultTimeout(timeout) or page.setDefaultTimeout(timeout) methods.
-        force : Optional[bool]
-            Whether to bypass the actionability checks. Defaults to `false`.
-        no_wait_after : Optional[bool]
-            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`.
-        """
+        name : str
+            CSS property name.
+        value : Union[Pattern[str], str]
+            CSS property value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_css(
+                    name=name, value=value, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-        try:
-            log_api("=> page.uncheck started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.uncheck(
-                        selector=selector,
-                        timeout=timeout,
-                        force=force,
-                        noWaitAfter=no_wait_after,
-                    )
-                )
-            )
-            log_api("<= page.uncheck succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.uncheck failed")
-            raise e
-
-    def wait_for_timeout(self, timeout: int) -> NoneType:
-        """Page.wait_for_timeout
+    def to_have_id(
+        self,
+        id: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_id
+
+        Ensures the `Locator` points to an element with the given DOM Node ID.
+
+        **Usage**
+
+        ```py
+        from playwright.sync_api import expect
 
-        Returns a promise that resolves after the timeout.
-        Note that `page.wait_for_timeout()` 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.
-        Shortcut for main frame's frame.wait_for_timeout(timeout).
+        locator = page.get_by_role(\"textbox\")
+        expect(locator).to_have_id(\"lastname\")
+        ```
 
         Parameters
         ----------
-        timeout : int
-            A timeout to wait for
+        id : Union[Pattern[str], str]
+            Element id.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.wait_for_timeout started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.waitForTimeout(timeout=timeout))
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_id(id=id, timeout=to_milliseconds(timeout))
             )
-            log_api("<= page.wait_for_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_timeout failed")
-            raise e
+        )
 
-    def wait_for_function(
+    def not_to_have_id(
         self,
-        expression: str,
-        arg: typing.Any = None,
-        force_expr: bool = None,
-        timeout: int = None,
-        polling: typing.Union[int, Literal["raf"]] = None,
-    ) -> "JSHandle":
-        """Page.wait_for_function
+        id: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_id
 
-        Returns when the `pageFunction` returns a truthy value. It resolves to a JSHandle of the truthy value.
-        The `waitForFunction` can be used to observe viewport size change:
-
-        To pass an argument from Node.js to the predicate of `page.wait_for_function` function:
-        Shortcut for main frame's frame.wait_for_function(pageFunction[, arg, options]).
+        The opposite of `locator_assertions.to_have_id()`.
 
         Parameters
         ----------
-        expression : str
-            Function to be evaluated in browser context
-        force_expr : bool
-            Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function
-        arg : Optional[Any]
-            Optional argument to pass to `pageFunction`
-        timeout : Optional[int]
-            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).
-        polling : Union[int, 'raf', NoneType]
-            If `polling` is `'raf'`, then `pageFunction` is constantly executed in `requestAnimationFrame` callback. If `polling` is a number, then it is treated as an interval in milliseconds at which the function would be executed. Defaults to `raf`.
-
-        Returns
-        -------
-        JSHandle
+        id : Union[Pattern[str], str]
+            Element id.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.wait_for_function started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.waitForFunction(
-                        expression=expression,
-                        arg=mapping.to_impl(arg),
-                        force_expr=force_expr,
-                        timeout=timeout,
-                        polling=polling,
-                    )
-                )
-            )
-            log_api("<= page.wait_for_function succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.wait_for_function failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_id(id=id, timeout=to_milliseconds(timeout))
+            )
+        )
 
-    def pdf(
+    def to_have_js_property(
         self,
-        scale: int = None,
-        display_header_footer: bool = None,
-        header_template: str = None,
-        footer_template: str = None,
-        print_background: bool = None,
-        landscape: bool = None,
-        page_ranges: str = None,
-        format: str = None,
-        width: typing.Union[str, float] = None,
-        height: typing.Union[str, float] = None,
-        prefer_css_page_size: bool = None,
-        margin: "PdfMargins" = None,
-        path: typing.Union[str, pathlib.Path] = None,
-    ) -> bytes:
-        """Page.pdf
+        name: str,
+        value: typing.Any,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_js_property
 
-        Returns the PDF buffer.
+        Ensures the `Locator` points to an element with given JavaScript property. Note that this property can be of a
+        primitive type as well as a plain serializable JavaScript object.
 
-        **NOTE** Generating a pdf is currently only supported in Chromium headless.
+        **Usage**
 
-        `page.pdf()` generates a pdf of the page with `print` css media. To generate a pdf with `screen` media, call
-        page.emulate_media(params) before calling `page.pdf()`:
+        ```py
+        from playwright.sync_api import expect
 
-        **NOTE** By default, `page.pdf()` generates a pdf with modified colors for printing. Use the
-        `-webkit-print-color-adjust` property to
-        force rendering of exact colors.
+        locator = page.locator(\".component\")
+        expect(locator).to_have_js_property(\"loaded\", True)
+        ```
 
-        The `width`, `height`, and `margin` options accept values labeled with units. Unlabeled values are treated as pixels.
-        A few examples:
+        Parameters
+        ----------
+        name : str
+            Property name.
+        value : Any
+            Property value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_js_property(
+                    name=name,
+                    value=mapping.to_impl(value),
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
 
-        `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.
+    def not_to_have_js_property(
+        self,
+        name: str,
+        value: typing.Any,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_js_property
 
-        All possible units are:
+        The opposite of `locator_assertions.to_have_js_property()`.
+
+        Parameters
+        ----------
+        name : str
+            Property name.
+        value : Any
+            Property value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_js_property(
+                    name=name,
+                    value=mapping.to_impl(value),
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
 
-        `px` - pixel
-        `in` - inch
-        `cm` - centimeter
-        `mm` - millimeter
+    def to_have_value(
+        self,
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_value
 
-        The `format` options are:
+        Ensures the `Locator` points to an element with the given input value. You can use regular expressions for the
+        value as well.
 
-        `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
+        **Usage**
 
-        **NOTE** `headerTemplate` and `footerTemplate` markup have the following limitations:
+        ```py
+        import re
+        from playwright.sync_api import expect
 
-        Script tags inside templates are not evaluated.
-        Page styles are not visible inside templates.
+        locator = page.locator(\"input[type=number]\")
+        expect(locator).to_have_value(re.compile(r\"[0-9]\"))
+        ```
 
         Parameters
         ----------
-        scale : Optional[int]
-            Scale of the webpage rendering. Defaults to `1`. Scale amount must be between 0.1 and 2.
-        display_header_footer : Optional[bool]
-            Display header and footer. Defaults to `false`.
-        header_template : Optional[str]
-            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
-        footer_template : Optional[str]
-            HTML template for the print footer. Should use the same format as the `headerTemplate`.
-        print_background : Optional[bool]
-            Print background graphics. Defaults to `false`.
-        landscape : Optional[bool]
-            Paper orientation. Defaults to `false`.
-        page_ranges : Optional[str]
-            Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty string, which means print all pages.
-        format : Optional[str]
-            Paper format. If set, takes priority over `width` or `height` options. Defaults to 'Letter'.
-        width : Union[str, float, NoneType]
-            Paper width, accepts values labeled with units.
-        height : Union[str, float, NoneType]
-            Paper height, accepts values labeled with units.
-        prefer_css_page_size : Optional[bool]
-            Give any CSS `@page` size declared in the page priority over what is declared in `width` and `height` or `format` options. Defaults to `false`, which will scale the content to fit the paper size.
-        margin : Optional[{"top": Union[str, int, NoneType], "right": Union[str, int, NoneType], "bottom": Union[str, int, NoneType], "left": Union[str, int, NoneType]}]
-            Paper margins, defaults to none.
-        path : Union[str, pathlib.Path, NoneType]
-            The file path to save the PDF to. If `path` is a relative path, then it is resolved relative to current working directory. If no path is provided, the PDF won't be saved to the disk.
-
-        Returns
-        -------
-        bytes
+        value : Union[Pattern[str], str]
+            Expected value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> page.pdf started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.pdf(
-                        scale=scale,
-                        displayHeaderFooter=display_header_footer,
-                        headerTemplate=header_template,
-                        footerTemplate=footer_template,
-                        printBackground=print_background,
-                        landscape=landscape,
-                        pageRanges=page_ranges,
-                        format=format,
-                        width=width,
-                        height=height,
-                        preferCSSPageSize=prefer_css_page_size,
-                        margin=margin,
-                        path=path,
-                    )
-                )
-            )
-            log_api("<= page.pdf succeded")
-            return result
-        except Exception as e:
-            log_api("<= page.pdf failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_value(
+                    value=value, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def expect_event(
+    def not_to_have_value(
         self,
-        event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
-    ) -> EventContextManager:
-        """Page.expect_event
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        value: typing.Union[str, typing.Pattern[str]],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_value
 
-        with page.expect_event() as event_info:
-            page.click("button")
-        value = event_info.value
+        The opposite of `locator_assertions.to_have_value()`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        value : Union[Pattern[str], str]
+            Expected value.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        return EventContextManager(
-            self, self._impl_obj.waitForEvent(event, predicate, timeout)
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_value(
+                    value=value, timeout=to_milliseconds(timeout)
+                )
+            )
         )
 
-    def expect_console_message(
+    def to_have_values(
         self,
-        predicate: typing.Union[typing.Callable[["ConsoleMessage"], bool]] = None,
-        timeout: int = None,
-    ) -> EventContextManager["ConsoleMessage"]:
-        """Page.expect_console_message
+        values: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_values
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        Ensures the `Locator` points to multi-select/combobox (i.e. a `select` with the `multiple` attribute) and the
+        specified values are selected.
 
-        with page.expect_console() as event_info:
-            page.click("button")
-        value = event_info.value
+        **Usage**
 
-        Parameters
-        ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        event = "console"
-        return EventContextManager(
-            self, self._impl_obj.waitForEvent(event, predicate, timeout)
-        )
+        For example, given the following element:
 
-    def expect_download(
-        self,
-        predicate: typing.Union[typing.Callable[["Download"], bool]] = None,
-        timeout: int = None,
-    ) -> EventContextManager["Download"]:
-        """Page.expect_download
+        ```html
+        <select id=\"favorite-colors\" multiple>
+          <option value=\"R\">Red</option>
+          <option value=\"G\">Green</option>
+          <option value=\"B\">Blue</option>
+        </select>
+        ```
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        ```py
+        import re
+        from playwright.sync_api import expect
 
-        with page.expect_download() as event_info:
-            page.click("button")
-        value = event_info.value
+        locator = page.locator(\"id=favorite-colors\")
+        locator.select_option([\"R\", \"G\"])
+        expect(locator).to_have_values([re.compile(r\"R\"), re.compile(r\"G\")])
+        ```
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        values : Union[Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str]]
+            Expected options currently selected.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        event = "download"
-        return EventContextManager(
-            self, self._impl_obj.waitForEvent(event, predicate, timeout)
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_values(
+                    values=mapping.to_impl(values), timeout=to_milliseconds(timeout)
+                )
+            )
         )
 
-    def expect_file_chooser(
+    def not_to_have_values(
         self,
-        predicate: typing.Union[typing.Callable[["FileChooser"], bool]] = None,
-        timeout: int = None,
-    ) -> EventContextManager["FileChooser"]:
-        """Page.expect_file_chooser
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        values: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_values
 
-        with page.expect_filechooser() as event_info:
-            page.click("button")
-        value = event_info.value
+        The opposite of `locator_assertions.to_have_values()`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        values : Union[Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str]]
+            Expected options currently selected.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        event = "filechooser"
-        return EventContextManager(
-            self, self._impl_obj.waitForEvent(event, predicate, timeout)
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_values(
+                    values=mapping.to_impl(values), timeout=to_milliseconds(timeout)
+                )
+            )
         )
 
-    def expect_load_state(
+    def to_have_text(
         self,
-        state: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> EventContextManager[typing.Union["Response", NoneType]]:
-        """Page.expect_load_state
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
+        ],
+        *,
+        use_inner_text: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_text
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        Ensures the `Locator` points to an element with the given text. All nested elements will be considered when
+        computing the text content of the element. You can use regular expressions for the value as well.
 
-        with page.expect_loadstate() as event_info:
-            page.click("button")
-        value = event_info.value
+        **Details**
 
-        Parameters
-        ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        return EventContextManager(
-            self, self._impl_obj.waitForLoadState(state, timeout)
-        )
+        When `expected` parameter is a string, Playwright will normalize whitespaces and line breaks both in the actual
+        text and in the expected string before matching. When regular expression is used, the actual text is matched as is.
 
-    def expect_navigation(
-        self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        wait_until: Literal["domcontentloaded", "load", "networkidle"] = None,
-        timeout: int = None,
-    ) -> EventContextManager[typing.Union["Response", NoneType]]:
-        """Page.expect_navigation
+        **Usage**
+
+        ```py
+        import re
+        from playwright.sync_api import expect
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        locator = page.locator(\".title\")
+        expect(locator).to_have_text(re.compile(r\"Welcome, Test User\"))
+        expect(locator).to_have_text(re.compile(r\"Welcome, .*\"))
+        ```
 
-        with page.expect_navigation() as event_info:
-            page.click("button")
-        value = event_info.value
+        If you pass an array as an expected value, the expectations are:
+        1. Locator resolves to a list of elements.
+        1. The number of elements equals the number of expected values in the array.
+        1. Elements from the list have text matching expected array values, one by one, in order.
 
-        Parameters
-        ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        return EventContextManager(
-            self, self._impl_obj.waitForNavigation(url, wait_until, timeout)
-        )
+        For example, consider the following list:
 
-    def expect_popup(
-        self,
-        predicate: typing.Union[typing.Callable[["Page"], bool]] = None,
-        timeout: int = None,
-    ) -> EventContextManager["Page"]:
-        """Page.expect_popup
+        ```html
+        <ul>
+          <li>Text 1</li>
+          <li>Text 2</li>
+          <li>Text 3</li>
+        </ul>
+        ```
+
+        Let's see how we can use the assertion:
+
+        ```py
+        from playwright.sync_api import expect
+
+        # ✓ Has the right items in the right order
+        expect(page.locator(\"ul > li\")).to_have_text([\"Text 1\", \"Text 2\", \"Text 3\"])
+
+        # ✖ Wrong order
+        expect(page.locator(\"ul > li\")).to_have_text([\"Text 3\", \"Text 2\", \"Text 1\"])
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        # ✖ Last item does not match
+        expect(page.locator(\"ul > li\")).to_have_text([\"Text 1\", \"Text 2\", \"Text\"])
 
-        with page.expect_popup() as event_info:
-            page.click("button")
-        value = event_info.value
+        # ✖ Locator points to the outer list element, not to the list items
+        expect(page.locator(\"ul\")).to_have_text([\"Text 1\", \"Text 2\", \"Text 3\"])
+        ```
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        event = "popup"
-        return EventContextManager(
-            self, self._impl_obj.waitForEvent(event, predicate, timeout)
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected string or RegExp or a list of those.
+        use_inner_text : Union[bool, None]
+            Whether to use `element.innerText` instead of `element.textContent` when retrieving DOM node text.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_text(
+                    expected=mapping.to_impl(expected),
+                    useInnerText=use_inner_text,
+                    timeout=to_milliseconds(timeout),
+                    ignoreCase=ignore_case,
+                )
+            )
         )
 
-    def expect_request(
+    def not_to_have_text(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        predicate: typing.Union[typing.Callable[["Request"], bool]] = None,
-        timeout: int = None,
-    ) -> EventContextManager["Request"]:
-        """Page.expect_request
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        expected: typing.Union[
+            typing.Sequence[str],
+            typing.Sequence[typing.Pattern[str]],
+            typing.Sequence[typing.Union[typing.Pattern[str], str]],
+            typing.Pattern[str],
+            str,
+        ],
+        *,
+        use_inner_text: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        ignore_case: typing.Optional[bool] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_text
 
-        with page.expect_request() as event_info:
-            page.click("button")
-        value = event_info.value
+        The opposite of `locator_assertions.to_have_text()`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        return EventContextManager(
-            self, self._impl_obj.waitForRequest(url, predicate, timeout)
+        expected : Union[Pattern[str], Sequence[Pattern[str]], Sequence[Union[Pattern[str], str]], Sequence[str], str]
+            Expected string or RegExp or a list of those.
+        use_inner_text : Union[bool, None]
+            Whether to use `element.innerText` instead of `element.textContent` when retrieving DOM node text.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_text(
+                    expected=mapping.to_impl(expected),
+                    useInnerText=use_inner_text,
+                    timeout=to_milliseconds(timeout),
+                    ignoreCase=ignore_case,
+                )
+            )
         )
 
-    def expect_response(
+    def to_be_attached(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]] = None,
-        predicate: typing.Union[typing.Callable[["Request"], bool]] = None,
-        timeout: int = None,
-    ) -> EventContextManager["Response"]:
-        """Page.expect_response
+        *,
+        attached: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_attached
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        Ensures that `Locator` points to an element that is
+        [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.
 
-        with page.expect_response() as event_info:
-            page.click("button")
-        value = event_info.value
+        **Usage**
+
+        ```py
+        expect(page.get_by_text(\"Hidden text\")).to_be_attached()
+        ```
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        attached : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        return EventContextManager(
-            self, self._impl_obj.waitForResponse(url, predicate, timeout)
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_be_attached(
+                    attached=attached, timeout=to_milliseconds(timeout)
+                )
+            )
         )
 
-    def expect_worker(
+    def to_be_checked(
         self,
-        predicate: typing.Union[typing.Callable[["Worker"], bool]] = None,
-        timeout: int = None,
-    ) -> EventContextManager["Worker"]:
-        """Page.expect_worker
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+        checked: typing.Optional[bool] = None,
+        indeterminate: typing.Optional[bool] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_checked
+
+        Ensures the `Locator` points to a checked input.
 
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        **Usage**
 
-        with page.expect_worker() as event_info:
-            page.click("button")
-        value = event_info.value
+        ```py
+        from playwright.sync_api import expect
+
+        locator = page.get_by_label(\"Subscribe to newsletter\")
+        expect(locator).to_be_checked()
+        ```
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        event = "worker"
-        return EventContextManager(
-            self, self._impl_obj.waitForEvent(event, predicate, timeout)
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        checked : Union[bool, None]
+            Provides state to assert for. Asserts for input to be checked by default. This option can't be used when
+            `indeterminate` is set to true.
+        indeterminate : Union[bool, None]
+            Asserts that the element is in the indeterminate (mixed) state. Only supported for checkboxes and radio buttons.
+            This option can't be true when `checked` is provided.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_be_checked(
+                    timeout=to_milliseconds(timeout),
+                    checked=checked,
+                    indeterminate=indeterminate,
+                )
+            )
         )
 
+    def not_to_be_attached(
+        self,
+        *,
+        attached: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_attached
 
-mapping.register(PageImpl, Page)
+        The opposite of `locator_assertions.to_be_attached()`.
 
+        Parameters
+        ----------
+        attached : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
 
-class BrowserContext(SyncBase):
-    def __init__(self, obj: BrowserContextImpl):
-        super().__init__(obj)
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_be_attached(
+                    attached=attached, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    @property
-    def pages(self) -> typing.List["Page"]:
-        """BrowserContext.pages
+    def not_to_be_checked(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_checked
 
-        Returns all open pages in the context. Non visible pages, such as `"background_page"`, will not be listed here. You can
-        find them using chromium_browser_context.background_pages().
+        The opposite of `locator_assertions.to_be_checked()`.
 
-        Returns
-        -------
-        List[Page]
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        return mapping.from_impl_list(self._impl_obj.pages)
+        __tracebackhide__ = True
 
-    @property
-    def browser(self) -> typing.Union["Browser", NoneType]:
-        """BrowserContext.browser
-
-        Returns the browser instance of the context. If it was launched as a persistent context null gets returned.
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_be_checked(timeout=to_milliseconds(timeout))
+            )
+        )
 
-        Returns
-        -------
-        Optional[Browser]
-        """
-        return mapping.from_impl_nullable(self._impl_obj.browser)
+    def to_be_disabled(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_disabled
 
-    def set_default_navigation_timeout(self, timeout: int) -> NoneType:
-        """BrowserContext.set_default_navigation_timeout
+        Ensures the `Locator` points to a disabled element. Element is disabled if it has \"disabled\" attribute or is
+        disabled via
+        ['aria-disabled'](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-disabled). Note
+        that only native control elements such as HTML `button`, `input`, `select`, `textarea`, `option`, `optgroup` can be
+        disabled by setting \"disabled\" attribute. \"disabled\" attribute on other elements is ignored by the browser.
 
-        This setting will change the default maximum navigation time for the following methods and related shortcuts:
+        **Usage**
 
-        page.go_back([options])
-        page.go_forward([options])
-        page.goto(url[, options])
-        page.reload([options])
-        page.set_content(html[, options])
-        page.wait_for_navigation([options])
+        ```py
+        from playwright.sync_api import expect
 
-        **NOTE** page.set_default_navigation_timeout(timeout) and page.set_default_timeout(timeout) take priority over
-        browser_context.set_default_navigation_timeout(timeout).
+        locator = page.locator(\"button.submit\")
+        expect(locator).to_be_disabled()
+        ```
 
         Parameters
         ----------
-        timeout : int
-            Maximum navigation time in milliseconds
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.set_default_navigation_timeout started")
-            result = mapping.from_maybe_impl(
-                self._impl_obj.setDefaultNavigationTimeout(timeout=timeout)
-            )
-            log_api("<= browser_context.set_default_navigation_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.set_default_navigation_timeout failed")
-            raise e
-
-    def set_default_timeout(self, timeout: int) -> NoneType:
-        """BrowserContext.set_default_timeout
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.to_be_disabled(timeout=to_milliseconds(timeout)))
+        )
 
-        This setting will change the default maximum time for all the methods accepting `timeout` option.
+    def not_to_be_disabled(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_disabled
 
-        **NOTE** page.set_default_navigation_timeout(timeout), page.set_default_timeout(timeout) and
-        browser_context.set_default_navigation_timeout(timeout) take priority over browser_context.set_default_timeout(timeout).
+        The opposite of `locator_assertions.to_be_disabled()`.
 
         Parameters
         ----------
-        timeout : int
-            Maximum time in milliseconds
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.set_default_timeout started")
-            result = mapping.from_maybe_impl(
-                self._impl_obj.setDefaultTimeout(timeout=timeout)
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_be_disabled(timeout=to_milliseconds(timeout))
             )
-            log_api("<= browser_context.set_default_timeout succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.set_default_timeout failed")
-            raise e
-
-    def new_page(self) -> "Page":
-        """BrowserContext.new_page
+        )
 
-        Creates a new page in the browser context.
+    def to_be_editable(
+        self,
+        *,
+        editable: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_editable
 
-        Returns
-        -------
-        Page
-        """
+        Ensures the `Locator` points to an editable element.
 
-        try:
-            log_api("=> browser_context.new_page started")
-            result = mapping.from_impl(self._sync(self._impl_obj.newPage()))
-            log_api("<= browser_context.new_page succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.new_page failed")
-            raise e
+        **Usage**
 
-    def cookies(
-        self, urls: typing.Union[str, typing.List[str]] = None
-    ) -> typing.List["Cookie"]:
-        """BrowserContext.cookies
+        ```py
+        from playwright.sync_api import expect
 
-        If no URLs are specified, this method returns all cookies. If URLs are specified, only cookies that affect those URLs
-        are returned.
+        locator = page.get_by_role(\"textbox\")
+        expect(locator).to_be_editable()
+        ```
 
         Parameters
         ----------
-        urls : Union[str, List[str], NoneType]
-            Optional list of URLs.
-
-        Returns
-        -------
-        List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]
+        editable : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.cookies started")
-            result = mapping.from_impl_list(
-                self._sync(self._impl_obj.cookies(urls=urls))
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_be_editable(
+                    editable=editable, timeout=to_milliseconds(timeout)
+                )
             )
-            log_api("<= browser_context.cookies succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.cookies failed")
-            raise e
+        )
 
-    def add_cookies(self, cookies: typing.List["Cookie"]) -> NoneType:
-        """BrowserContext.add_cookies
+    def not_to_be_editable(
+        self,
+        *,
+        editable: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_editable
 
-        Adds cookies into this browser context. All pages within this context will have these cookies installed. Cookies can be
-        obtained via browser_context.cookies([urls]).
+        The opposite of `locator_assertions.to_be_editable()`.
 
         Parameters
         ----------
-        cookies : List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]
+        editable : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.add_cookies started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.addCookies(cookies=cookies))
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_be_editable(
+                    editable=editable, timeout=to_milliseconds(timeout)
+                )
             )
-            log_api("<= browser_context.add_cookies succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.add_cookies failed")
-            raise e
+        )
 
-    def clear_cookies(self) -> NoneType:
-        """BrowserContext.clear_cookies
+    def to_be_empty(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_empty
 
-        Clears context cookies.
-        """
+        Ensures the `Locator` points to an empty editable element or to a DOM node that has no text.
 
-        try:
-            log_api("=> browser_context.clear_cookies started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.clearCookies()))
-            log_api("<= browser_context.clear_cookies succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.clear_cookies failed")
-            raise e
+        **Usage**
 
-    def grant_permissions(
-        self, permissions: typing.List[str], origin: str = None
-    ) -> NoneType:
-        """BrowserContext.grant_permissions
+        ```py
+        from playwright.sync_api import expect
 
-        Grants specified permissions to the browser context. Only grants corresponding permissions to the given origin if
-        specified.
+        locator = page.locator(\"div.warning\")
+        expect(locator).to_be_empty()
+        ```
 
         Parameters
         ----------
-        permissions : List[str]
-            A permission or an array of permissions to grant. Permissions can be one of the following values:
-             - `'geolocation'`
-             - `'midi'`
-             - `'midi-sysex'` (system-exclusive midi)
-             - `'notifications'`
-             - `'push'`
-             - `'camera'`
-             - `'microphone'`
-             - `'background-sync'`
-             - `'ambient-light-sensor'`
-             - `'accelerometer'`
-             - `'gyroscope'`
-             - `'magnetometer'`
-             - `'accessibility-events'`
-             - `'clipboard-read'`
-             - `'clipboard-write'`
-             - `'payment-handler'`
-        origin : Optional[str]
-            The origin to grant permissions to, e.g. "https://example.com".
-        """
-
-        try:
-            log_api("=> browser_context.grant_permissions started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.grantPermissions(
-                        permissions=permissions, origin=origin
-                    )
-                )
-            )
-            log_api("<= browser_context.grant_permissions succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.grant_permissions failed")
-            raise e
-
-    def clear_permissions(self) -> NoneType:
-        """BrowserContext.clear_permissions
-
-        Clears all permission overrides for the browser context.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.clear_permissions started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.clearPermissions())
-            )
-            log_api("<= browser_context.clear_permissions succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.clear_permissions failed")
-            raise e
-
-    def set_geolocation(
-        self, latitude: float, longitude: float, accuracy: float = None
-    ) -> NoneType:
-        """BrowserContext.set_geolocation
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.to_be_empty(timeout=to_milliseconds(timeout)))
+        )
 
-        Sets the context's geolocation. Passing `null` or `undefined` emulates position unavailable.
+    def not_to_be_empty(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_empty
 
-        **NOTE** Consider using browser_context.grant_permissions(permissions[, options]) to grant permissions for the browser context pages to
-        read its geolocation.
+        The opposite of `locator_assertions.to_be_empty()`.
 
         Parameters
         ----------
-        latitude : float
-            Latitude between -90 and 90. **required**
-        longitude : float
-            Longitude between -180 and 180. **required**
-        accuracy : Optional[float]
-            Non-negative accuracy value. Defaults to `0`.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.set_geolocation started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.setGeolocation(
-                        latitude=latitude, longitude=longitude, accuracy=accuracy
-                    )
-                )
-            )
-            log_api("<= browser_context.set_geolocation succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.set_geolocation failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.not_to_be_empty(timeout=to_milliseconds(timeout)))
+        )
 
-    def reset_geolocation(self) -> NoneType:
+    def to_be_enabled(
+        self,
+        *,
+        enabled: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_enabled
 
-        try:
-            log_api("=> browser_context.reset_geolocation started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.resetGeolocation())
-            )
-            log_api("<= browser_context.reset_geolocation succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.reset_geolocation failed")
-            raise e
+        Ensures the `Locator` points to an enabled element.
 
-    def set_extra_http_headers(self, headers: typing.Dict[str, str]) -> NoneType:
-        """BrowserContext.set_extra_http_headers
+        **Usage**
 
-        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.set_extra_http_headers(headers). If page overrides a particular header,
-        page-specific header value will be used instead of the browser context header value.
+        ```py
+        from playwright.sync_api import expect
 
-        **NOTE** `browser_context.set_extra_http_headers` does not guarantee the order of headers in the outgoing requests.
+        locator = page.locator(\"button.submit\")
+        expect(locator).to_be_enabled()
+        ```
 
         Parameters
         ----------
-        headers : Dict[str, str]
-            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
+        enabled : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.set_extra_http_headers started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.setExtraHTTPHeaders(headers=mapping.to_impl(headers))
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_be_enabled(
+                    enabled=enabled, timeout=to_milliseconds(timeout)
                 )
             )
-            log_api("<= browser_context.set_extra_http_headers succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.set_extra_http_headers failed")
-            raise e
+        )
 
-    def set_offline(self, offline: bool) -> NoneType:
-        """BrowserContext.set_offline
+    def not_to_be_enabled(
+        self,
+        *,
+        enabled: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_enabled
+
+        The opposite of `locator_assertions.to_be_enabled()`.
 
         Parameters
         ----------
-        offline : bool
-            Whether to emulate network being offline for the browser context.
+        enabled : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.set_offline started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.setOffline(offline=offline))
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_be_enabled(
+                    enabled=enabled, timeout=to_milliseconds(timeout)
+                )
             )
-            log_api("<= browser_context.set_offline succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.set_offline failed")
-            raise e
+        )
 
-    def add_init_script(
-        self, source: str = None, path: typing.Union[str, pathlib.Path] = None
-    ) -> NoneType:
-        """BrowserContext.add_init_script
+    def to_be_hidden(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_hidden
 
-        Adds a script which would be evaluated in one of the following scenarios:
+        Ensures that `Locator` either does not resolve to any DOM node, or resolves to a
+        [non-visible](https://playwright.dev/python/docs/actionability#visible) one.
 
-        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.
+        **Usage**
 
-        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`.
-        An example of overriding `Math.random` before the page loads:
+        ```py
+        from playwright.sync_api import expect
 
-        **NOTE** The order of evaluation of multiple scripts installed via browser_context.add_init_script(script[, arg]) and
-        page.add_init_script(script[, arg]) is not defined.
+        locator = page.locator('.my-element')
+        expect(locator).to_be_hidden()
+        ```
 
         Parameters
         ----------
-        source : Optional[str]
-            Script to be evaluated in all pages in the browser context.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.add_init_script started")
-            result = mapping.from_maybe_impl(
-                self._sync(self._impl_obj.addInitScript(source=source, path=path))
-            )
-            log_api("<= browser_context.add_init_script succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.add_init_script failed")
-            raise e
-
-    def expose_binding(
-        self, name: str, binding: typing.Callable, handle: bool = None
-    ) -> NoneType:
-        """BrowserContext.expose_binding
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.to_be_hidden(timeout=to_milliseconds(timeout)))
+        )
 
-        The method adds a function called `name` on the `window` object of every frame in every page in the context. When
-        called, the function executes `playwrightBinding` in Node.js and returns a Promise which resolves to the return value
-        of `playwrightBinding`. If the `playwrightBinding` returns a Promise, it will be awaited.
-        The first argument of the `playwrightBinding` function contains information about the caller: `{ browserContext: BrowserContext, page: Page, frame: Frame }`.
-        See page.expose_binding(name, playwrightBinding[, options]) for page-only version.
-        An example of exposing page URL to all frames in all pages in the context:
+    def not_to_be_hidden(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_hidden
 
-        An example of passing an element handle:
+        The opposite of `locator_assertions.to_be_hidden()`.
 
         Parameters
         ----------
-        name : str
-            Name of the function on the window object.
-        binding : Callable
-            Callback function that will be called in the Playwright's context.
-        handle : Optional[bool]
-            Whether to pass the argument as a handle, instead of passing by value. When passing a handle, only one argument is supported. When passing by value, multiple arguments are supported.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.expose_binding started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.exposeBinding(
-                        name=name, binding=self._wrap_handler(binding), handle=handle
-                    )
-                )
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_be_hidden(timeout=to_milliseconds(timeout))
             )
-            log_api("<= browser_context.expose_binding succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.expose_binding failed")
-            raise e
+        )
 
-    def expose_function(self, name: str, binding: typing.Callable) -> NoneType:
-        """BrowserContext.expose_function
+    def to_be_visible(
+        self,
+        *,
+        visible: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_visible
 
-        The method adds a function called `name` on the `window` object of every frame in every page in the context. When
-        called, the function executes `playwrightFunction` in Node.js and returns a Promise which resolves to the return value
-        of `playwrightFunction`.
-        If the `playwrightFunction` returns a Promise, it will be awaited.
-        See page.expose_function(name, playwrightFunction) for page-only version.
-        An example of adding an `md5` function to all pages in the context:
+        Ensures that `Locator` points to an attached and [visible](https://playwright.dev/python/docs/actionability#visible) DOM node.
 
-        Parameters
-        ----------
-        name : str
-            Name of the function on the window object.
-        binding : Callable
-            Callback function that will be called in the Playwright's context.
-        """
+        To check that at least one element from the list is visible, use `locator.first()`.
 
-        try:
-            log_api("=> browser_context.expose_function started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.exposeFunction(
-                        name=name, binding=self._wrap_handler(binding)
-                    )
-                )
-            )
-            log_api("<= browser_context.expose_function succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.expose_function failed")
-            raise e
+        **Usage**
 
-    def route(
-        self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]],
-        handler: typing.Union[
-            typing.Callable[["Route"], typing.Any],
-            typing.Callable[["Route", "Request"], typing.Any],
-        ],
-    ) -> NoneType:
-        """BrowserContext.route
+        ```py
+        # A specific element is visible.
+        expect(page.get_by_text(\"Welcome\")).to_be_visible()
 
-        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.
-        An example of a naïve handler that aborts all image requests:
-        or the same snippet using a regex pattern instead:
-        Page routes (set up with page.route(url, handler)) take precedence over browser context routes when request matches both
-        handlers.
+        # At least one item in the list is visible.
+        expect(page.get_by_test_id(\"todo-item\").first).to_be_visible()
 
-        **NOTE** Enabling routing disables http cache.
+        # At least one of the two elements is visible, possibly both.
+        expect(
+            page.get_by_role(\"button\", name=\"Sign in\")
+            .or_(page.get_by_role(\"button\", name=\"Sign up\"))
+            .first
+        ).to_be_visible()
+        ```
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool]]
-            A glob pattern, regex pattern or predicate receiving URL to match while routing.
-        handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any]]
-            handler function to route the request.
+        visible : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.route started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.route(
-                        url=self._wrap_handler(url), handler=self._wrap_handler(handler)
-                    )
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_be_visible(
+                    visible=visible, timeout=to_milliseconds(timeout)
                 )
             )
-            log_api("<= browser_context.route succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.route failed")
-            raise e
+        )
 
-    def unroute(
+    def not_to_be_visible(
         self,
-        url: typing.Union[str, typing.Pattern, typing.Callable[[str], bool]],
-        handler: typing.Union[
-            typing.Callable[["Route"], typing.Any],
-            typing.Callable[["Route", "Request"], typing.Any],
-        ] = None,
-    ) -> NoneType:
-        """BrowserContext.unroute
+        *,
+        visible: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_visible
 
-        Removes a route created with browser_context.route(url, handler). When `handler` is not specified, removes all routes for the
-        `url`.
+        The opposite of `locator_assertions.to_be_visible()`.
 
         Parameters
         ----------
-        url : Union[str, Pattern, Callable[[str], bool]]
-            A glob pattern, regex pattern or predicate receiving URL used to register a routing with browser_context.route(url, handler).
-        handler : Union[Callable[[Route], Any], Callable[[Route, Request], Any], NoneType]
-            Optional handler function used to register a routing with browser_context.route(url, handler).
+        visible : Union[bool, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.unroute started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.unroute(
-                        url=self._wrap_handler(url), handler=self._wrap_handler(handler)
-                    )
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_be_visible(
+                    visible=visible, timeout=to_milliseconds(timeout)
                 )
             )
-            log_api("<= browser_context.unroute succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.unroute failed")
-            raise e
+        )
 
-    def wait_for_event(
+    def to_be_focused(
         self,
-        event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
-    ) -> typing.Any:
-        """BrowserContext.wait_for_event
-
-        Waits for event to fire and passes its value into the predicate function. Resolves when the predicate returns truthy
-        value. Will throw an error if the context closes before the event is fired. Returns the event data value.
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_focused
 
-        Parameters
-        ----------
-        event : str
-            Event name, same one would pass into `browserContext.on(event)`.
+        Ensures the `Locator` points to a focused DOM node.
 
-        Returns
-        -------
-        Any
-        """
+        **Usage**
 
-        try:
-            log_api("=> browser_context.wait_for_event started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.waitForEvent(
-                        event=event,
-                        predicate=self._wrap_handler(predicate),
-                        timeout=timeout,
-                    )
-                )
-            )
-            log_api("<= browser_context.wait_for_event succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.wait_for_event failed")
-            raise e
-
-    def close(self) -> NoneType:
-        """BrowserContext.close
+        ```py
+        from playwright.sync_api import expect
 
-        Closes the browser context. All the pages that belong to the browser context will be closed.
+        locator = page.get_by_role(\"textbox\")
+        expect(locator).to_be_focused()
+        ```
 
-        **NOTE** the default browser context cannot be closed.
+        Parameters
+        ----------
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.close started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.close()))
-            log_api("<= browser_context.close succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.close failed")
-            raise e
-
-    def storage_state(
-        self, path: typing.Union[str, pathlib.Path] = None
-    ) -> "StorageState":
-        """BrowserContext.storage_state
+        return mapping.from_maybe_impl(
+            self._sync(self._impl_obj.to_be_focused(timeout=to_milliseconds(timeout)))
+        )
 
-        Returns storage state for this browser context, contains current cookies and local storage snapshot.
+    def not_to_be_focused(
+        self,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_focused
+
+        The opposite of `locator_assertions.to_be_focused()`.
 
         Parameters
         ----------
-        path : Union[str, pathlib.Path, NoneType]
-            The file path to save the storage state to. If `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.
-
-        Returns
-        -------
-        {"cookies": Optional[List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]], "origins": Optional[List[Dict]]}
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser_context.storage_state started")
-            result = mapping.from_impl(
-                self._sync(self._impl_obj.storageState(path=path))
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_be_focused(timeout=to_milliseconds(timeout))
             )
-            log_api("<= browser_context.storage_state succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_context.storage_state failed")
-            raise e
+        )
 
-    def expect_event(
+    def to_be_in_viewport(
         self,
-        event: str,
-        predicate: typing.Union[typing.Callable[[typing.Any], bool]] = None,
-        timeout: int = None,
-    ) -> EventContextManager:
-        """BrowserContext.expect_event
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
-
-        with page.expect_event() as event_info:
-            page.click("button")
-        value = event_info.value
+        *,
+        ratio: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_be_in_viewport
+
+        Ensures the `Locator` points to an element that intersects viewport, according to the
+        [intersection observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API).
+
+        **Usage**
+
+        ```py
+        from playwright.sync_api import expect
+
+        locator = page.get_by_role(\"button\")
+        # Make sure at least some part of element intersects viewport.
+        expect(locator).to_be_in_viewport()
+        # Make sure element is fully outside of viewport.
+        expect(locator).not_to_be_in_viewport()
+        # Make sure that at least half of the element intersects viewport.
+        expect(locator).to_be_in_viewport(ratio=0.5)
+        ```
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        """
-        return EventContextManager(
-            self, self._impl_obj.waitForEvent(event, predicate, timeout)
+        ratio : Union[float, None]
+            The minimal ratio of the element to intersect viewport. If equals to `0`, then element should intersect viewport at
+            any positive ratio. Defaults to `0`.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_be_in_viewport(
+                    ratio=ratio, timeout=to_milliseconds(timeout)
+                )
+            )
         )
 
-    def expect_page(
+    def not_to_be_in_viewport(
         self,
-        predicate: typing.Union[typing.Callable[["Page"], bool]] = None,
-        timeout: int = None,
-    ) -> EventContextManager["Page"]:
-        """BrowserContext.expect_page
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
+        *,
+        ratio: typing.Optional[float] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_be_in_viewport
 
-        with page.expect_page() as event_info:
-            page.click("button")
-        value = event_info.value
+        The opposite of `locator_assertions.to_be_in_viewport()`.
 
         Parameters
         ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
+        ratio : Union[float, None]
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
-        event = "page"
-        return EventContextManager(
-            self, self._impl_obj.waitForEvent(event, predicate, timeout)
-        )
+        __tracebackhide__ = True
 
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_be_in_viewport(
+                    ratio=ratio, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-mapping.register(BrowserContextImpl, BrowserContext)
+    def to_have_accessible_description(
+        self,
+        description: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_description
 
+        Ensures the `Locator` points to an element with a given
+        [accessible description](https://w3c.github.io/accname/#dfn-accessible-description).
 
-class CDPSession(SyncBase):
-    def __init__(self, obj: CDPSessionImpl):
-        super().__init__(obj)
+        **Usage**
 
-    def send(self, method: str, params: typing.Dict = None) -> typing.Dict:
-        """CDPSession.send
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        expect(locator).to_have_accessible_description(\"Save results to disk\")
+        ```
 
         Parameters
         ----------
-        method : str
-            protocol method name
-        params : Optional[Dict]
-            Optional method parameters
-
-        Returns
-        -------
-        Dict
-        """
-
-        try:
-            log_api("=> cdp_session.send started")
-            result = mapping.from_maybe_impl(
-                self._sync(
-                    self._impl_obj.send(method=method, params=mapping.to_impl(params))
+        description : Union[Pattern[str], str]
+            Expected accessible description.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_accessible_description(
+                    description=description,
+                    ignoreCase=ignore_case,
+                    timeout=to_milliseconds(timeout),
                 )
             )
-            log_api("<= cdp_session.send succeded")
-            return result
-        except Exception as e:
-            log_api("<= cdp_session.send failed")
-            raise e
-
-    def detach(self) -> NoneType:
-        """CDPSession.detach
+        )
 
-        Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be used to
-        send messages.
-        """
+    def not_to_have_accessible_description(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_description
 
-        try:
-            log_api("=> cdp_session.detach started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.detach()))
-            log_api("<= cdp_session.detach succeded")
-            return result
-        except Exception as e:
-            log_api("<= cdp_session.detach failed")
-            raise e
+        The opposite of `locator_assertions.to_have_accessible_description()`.
 
+        Parameters
+        ----------
+        name : Union[Pattern[str], str]
+            Expected accessible description.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_accessible_description(
+                    name=name, ignoreCase=ignore_case, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-mapping.register(CDPSessionImpl, CDPSession)
+    def to_have_accessible_name(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_name
 
+        Ensures the `Locator` points to an element with a given
+        [accessible name](https://w3c.github.io/accname/#dfn-accessible-name).
 
-class ChromiumBrowserContext(BrowserContext):
-    def __init__(self, obj: ChromiumBrowserContextImpl):
-        super().__init__(obj)
+        **Usage**
 
-    def background_pages(self) -> typing.List["Page"]:
-        """ChromiumBrowserContext.background_pages
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        expect(locator).to_have_accessible_name(\"Save to disk\")
+        ```
 
-        All existing background pages in the context.
+        Parameters
+        ----------
+        name : Union[Pattern[str], str]
+            Expected accessible name.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_accessible_name(
+                    name=name, ignoreCase=ignore_case, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-        Returns
-        -------
-        List[Page]
-        """
+    def not_to_have_accessible_name(
+        self,
+        name: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_name
 
-        try:
-            log_api("=> chromium_browser_context.background_pages started")
-            result = mapping.from_impl_list(self._impl_obj.backgroundPages())
-            log_api("<= chromium_browser_context.background_pages succeded")
-            return result
-        except Exception as e:
-            log_api("<= chromium_browser_context.background_pages failed")
-            raise e
+        The opposite of `locator_assertions.to_have_accessible_name()`.
 
-    def service_workers(self) -> typing.List["Worker"]:
-        """ChromiumBrowserContext.service_workers
+        Parameters
+        ----------
+        name : Union[Pattern[str], str]
+            Expected accessible name.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_accessible_name(
+                    name=name, ignoreCase=ignore_case, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-        All existing service workers in the context.
+    def to_have_role(
+        self,
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_role
 
-        Returns
-        -------
-        List[Worker]
-        """
+        Ensures the `Locator` points to an element with a given [ARIA role](https://www.w3.org/TR/wai-aria-1.2/#roles).
 
-        try:
-            log_api("=> chromium_browser_context.service_workers started")
-            result = mapping.from_impl_list(self._impl_obj.serviceWorkers())
-            log_api("<= chromium_browser_context.service_workers succeded")
-            return result
-        except Exception as e:
-            log_api("<= chromium_browser_context.service_workers failed")
-            raise e
+        Note that role is matched as a string, disregarding the ARIA role hierarchy. For example, asserting  a superclass
+        role `\"checkbox\"` on an element with a subclass role `\"switch\"` will fail.
 
-    def new_cdp_session(self, page: "Page") -> "CDPSession":
-        """ChromiumBrowserContext.new_cdp_session
+        **Usage**
 
-        Returns the newly created session.
+        ```py
+        locator = page.get_by_test_id(\"save-button\")
+        expect(locator).to_have_role(\"button\")
+        ```
 
         Parameters
         ----------
-        page : Page
-            Page to create new session for.
-
-        Returns
-        -------
-        CDPSession
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> chromium_browser_context.new_cdp_session started")
-            result = mapping.from_impl(
-                self._sync(self._impl_obj.newCDPSession(page=page._impl_obj))
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_role(role=role, timeout=to_milliseconds(timeout))
             )
-            log_api("<= chromium_browser_context.new_cdp_session succeded")
-            return result
-        except Exception as e:
-            log_api("<= chromium_browser_context.new_cdp_session failed")
-            raise e
-
-
-mapping.register(ChromiumBrowserContextImpl, ChromiumBrowserContext)
+        )
 
+    def to_have_accessible_error_message(
+        self,
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_have_accessible_error_message
 
-class Browser(SyncBase):
-    def __init__(self, obj: BrowserImpl):
-        super().__init__(obj)
+        Ensures the `Locator` points to an element with a given
+        [aria errormessage](https://w3c.github.io/aria/#aria-errormessage).
 
-    @property
-    def contexts(self) -> typing.List["BrowserContext"]:
-        """Browser.contexts
+        **Usage**
 
-        Returns an array of all open browser contexts. In a newly created browser, this will return zero browser contexts.
+        ```py
+        locator = page.get_by_test_id(\"username-input\")
+        expect(locator).to_have_accessible_error_message(\"Username is required.\")
+        ```
 
-        Returns
-        -------
-        List[BrowserContext]
-        """
-        return mapping.from_impl_list(self._impl_obj.contexts)
+        Parameters
+        ----------
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_have_accessible_error_message(
+                    errorMessage=error_message,
+                    ignoreCase=ignore_case,
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
 
-    @property
-    def version(self) -> str:
-        """Browser.version
+    def not_to_have_accessible_error_message(
+        self,
+        error_message: typing.Union[str, typing.Pattern[str]],
+        *,
+        ignore_case: typing.Optional[bool] = None,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_accessible_error_message
 
-        Returns the browser version.
+        The opposite of `locator_assertions.to_have_accessible_error_message()`.
 
-        Returns
-        -------
-        str
-        """
-        return mapping.from_maybe_impl(self._impl_obj.version)
+        Parameters
+        ----------
+        error_message : Union[Pattern[str], str]
+            Expected accessible error message.
+        ignore_case : Union[bool, None]
+            Whether to perform case-insensitive match. `ignoreCase` option takes precedence over the corresponding regular
+            expression flag if specified.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
+        """
+        __tracebackhide__ = True
+
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_accessible_error_message(
+                    errorMessage=error_message,
+                    ignoreCase=ignore_case,
+                    timeout=to_milliseconds(timeout),
+                )
+            )
+        )
 
-    def is_connected(self) -> bool:
-        """Browser.is_connected
+    def not_to_have_role(
+        self,
+        role: Literal[
+            "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",
+            "menu",
+            "menubar",
+            "menuitem",
+            "menuitemcheckbox",
+            "menuitemradio",
+            "meter",
+            "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",
+        ],
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_have_role
 
-        Indicates that the browser is connected.
+        The opposite of `locator_assertions.to_have_role()`.
 
-        Returns
-        -------
-        bool
+        Parameters
+        ----------
+        role : Union["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", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "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"]
+            Required aria role.
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser.is_connected started")
-            result = mapping.from_maybe_impl(self._impl_obj.isConnected())
-            log_api("<= browser.is_connected succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser.is_connected failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_have_role(
+                    role=role, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def new_context(
+    def to_match_aria_snapshot(
         self,
-        viewport: typing.Union[typing.Tuple[int, int], Literal[0]] = None,
-        ignore_https_errors: bool = None,
-        java_script_enabled: bool = None,
-        bypass_csp: bool = None,
-        user_agent: str = None,
-        locale: str = None,
-        timezone_id: str = None,
-        geolocation: "Geolocation" = None,
-        permissions: typing.List[str] = None,
-        extra_http_headers: typing.Union[typing.Dict[str, str]] = None,
-        offline: bool = None,
-        http_credentials: typing.Union[typing.Tuple[str, str]] = None,
-        device_scale_factor: int = None,
-        is_mobile: bool = None,
-        has_touch: bool = None,
-        color_scheme: Literal["dark", "light", "no-preference"] = None,
-        accept_downloads: bool = None,
-        default_browser_type: str = None,
-        proxy: "ProxySettings" = None,
-        record_har_path: typing.Union[str, pathlib.Path] = None,
-        record_har_omit_content: bool = None,
-        record_video_dir: typing.Union[str, pathlib.Path] = None,
-        record_video_size: typing.Union[typing.Tuple[int, int]] = None,
-        storage_state: typing.Union["StorageState", str, pathlib.Path] = None,
-    ) -> "BrowserContext":
-        """Browser.new_context
-
-        Creates a new browser context. It won't share cookies/cache with other browser contexts.
+        expected: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.to_match_aria_snapshot
+
+        Asserts that the target element matches the given [accessibility snapshot](https://playwright.dev/python/docs/aria-snapshots).
+
+        **Usage**
+
+        ```py
+        page.goto(\"https://demo.playwright.dev/todomvc/\")
+        expect(page.locator('body')).to_match_aria_snapshot('''
+          - heading \"todos\"
+          - textbox \"What needs to be done?\"
+        ''')
+        ```
 
         Parameters
         ----------
-        viewport : Union[typing.Tuple[int, int], '0', NoneType]
-            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `null` disables the default viewport.
-        ignore_https_errors : Optional[bool]
-            Whether to ignore HTTPS errors during navigation. Defaults to `false`.
-        java_script_enabled : Optional[bool]
-            Whether or not to enable JavaScript in the context. Defaults to `true`.
-        bypass_csp : Optional[bool]
-            Toggles bypassing page's Content-Security-Policy.
-        user_agent : Optional[str]
-            Specific user agent to use in this context.
-        locale : Optional[str]
-            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.
-        timezone_id : Optional[str]
-            Changes the timezone of the context. See ICU’s `metaZones.txt` for a list of supported timezone IDs.
-        geolocation : Optional[{"latitude": float, "longitude": float, "accuracy": Optional[float]}]
-        permissions : Optional[List[str]]
-            A list of permissions to grant to all pages in this context. See browserContext.grantPermissions(permissions[, options]) for more details.
-        extra_http_headers : Optional[Dict[str, str]]
-            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
-        offline : Optional[bool]
-            Whether to emulate network being offline. Defaults to `false`.
-        http_credentials : Optional[typing.Tuple[str, str]]
-            Credentials for HTTP authentication.
-        device_scale_factor : Optional[int]
-            Specify device scale factor (can be thought of as dpr). Defaults to `1`.
-        is_mobile : Optional[bool]
-            Whether the `meta viewport` tag is taken into account and touch events are enabled. Defaults to `false`. Not supported in Firefox.
-        has_touch : Optional[bool]
-            Specifies if viewport supports touch events. Defaults to false.
-        color_scheme : Optional[Literal['dark', 'light', 'no-preference']]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See page.emulateMedia(params) for more details. Defaults to '`light`'.
-        accept_downloads : Optional[bool]
-            Whether to automatically download all the attachments. Defaults to `false` where all the downloads are canceled.
-        proxy : Optional[{"server": str, "bypass": Optional[str], "username": Optional[str], "password": Optional[str]}]
-            Network proxy settings to use with this context. Note that browser needs to be launched with the global proxy for this option to work. If all contexts override the proxy, global proxy will be never used and can be any string, for example `launch({ proxy: { server: 'per-context' } })`.
-        record_har_path : Union[str, pathlib.Path, NoneType]
-            Path on the filesystem to write the HAR file to.
-        record_har_omit_content : Optional[bool]
-            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
-        record_video_dir : Union[str, pathlib.Path, NoneType]
-            Path to the directory to put videos into.
-        record_video_size : Optional[typing.Tuple[int, int]]
-            Optional dimensions of the recorded videos. If not specified the size will be equal to `viewport`. If `viewport` is not configured explicitly the video size defaults to 1280x720. Actual picture of each page will be scaled down if necessary to fit the specified size.
-        storage_state : Union[{"cookies": Optional[List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]], "origins": Optional[List[Dict]]}, str, pathlib.Path, NoneType]
-            Populates context with given storage state. This method can be used to initialize context with logged-in information obtained via browserContext.storageState([options]). Either a path to the file with saved storage, or an object with the following fields:
-
-        Returns
-        -------
-        BrowserContext
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser.new_context started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.newContext(
-                        viewport=viewport,
-                        ignoreHTTPSErrors=ignore_https_errors,
-                        javaScriptEnabled=java_script_enabled,
-                        bypassCSP=bypass_csp,
-                        userAgent=user_agent,
-                        locale=locale,
-                        timezoneId=timezone_id,
-                        geolocation=geolocation,
-                        permissions=permissions,
-                        extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                        offline=offline,
-                        httpCredentials=http_credentials,
-                        deviceScaleFactor=device_scale_factor,
-                        isMobile=is_mobile,
-                        hasTouch=has_touch,
-                        colorScheme=color_scheme,
-                        acceptDownloads=accept_downloads,
-                        defaultBrowserType=default_browser_type,
-                        proxy=proxy,
-                        recordHarPath=record_har_path,
-                        recordHarOmitContent=record_har_omit_content,
-                        recordVideoDir=record_video_dir,
-                        recordVideoSize=record_video_size,
-                        storageState=storage_state,
-                    )
-                )
-            )
-            log_api("<= browser.new_context succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser.new_context failed")
-            raise e
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.to_match_aria_snapshot(
+                    expected=expected, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-    def new_page(
+    def not_to_match_aria_snapshot(
         self,
-        viewport: typing.Union[typing.Tuple[int, int], Literal[0]] = None,
-        ignore_https_errors: bool = None,
-        java_script_enabled: bool = None,
-        bypass_csp: bool = None,
-        user_agent: str = None,
-        locale: str = None,
-        timezone_id: str = None,
-        geolocation: "Geolocation" = None,
-        permissions: typing.List[str] = None,
-        extra_http_headers: typing.Union[typing.Dict[str, str]] = None,
-        offline: bool = None,
-        http_credentials: typing.Union[typing.Tuple[str, str]] = None,
-        device_scale_factor: int = None,
-        is_mobile: bool = None,
-        has_touch: bool = None,
-        color_scheme: Literal["dark", "light", "no-preference"] = None,
-        accept_downloads: bool = None,
-        default_browser_type: str = None,
-        proxy: "ProxySettings" = None,
-        record_har_path: typing.Union[str, pathlib.Path] = None,
-        record_har_omit_content: bool = None,
-        record_video_dir: typing.Union[str, pathlib.Path] = None,
-        record_video_size: typing.Union[typing.Tuple[int, int]] = None,
-        storage_state: typing.Union["StorageState", str, pathlib.Path] = None,
-    ) -> "Page":
-        """Browser.new_page
+        expected: str,
+        *,
+        timeout: typing.Optional[typing.Union[float, datetime.timedelta]] = None,
+    ) -> None:
+        """LocatorAssertions.not_to_match_aria_snapshot
 
-        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.new_context([options]) followed by the browser_context.new_page() to
-        control their exact life times.
+        The opposite of `locator_assertions.to_match_aria_snapshot()`.
 
         Parameters
         ----------
-        viewport : Union[typing.Tuple[int, int], '0', NoneType]
-            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `null` disables the default viewport.
-        ignore_https_errors : Optional[bool]
-            Whether to ignore HTTPS errors during navigation. Defaults to `false`.
-        java_script_enabled : Optional[bool]
-            Whether or not to enable JavaScript in the context. Defaults to `true`.
-        bypass_csp : Optional[bool]
-            Toggles bypassing page's Content-Security-Policy.
-        user_agent : Optional[str]
-            Specific user agent to use in this context.
-        locale : Optional[str]
-            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.
-        timezone_id : Optional[str]
-            Changes the timezone of the context. See ICU’s `metaZones.txt` for a list of supported timezone IDs.
-        geolocation : Optional[{"latitude": float, "longitude": float, "accuracy": Optional[float]}]
-        permissions : Optional[List[str]]
-            A list of permissions to grant to all pages in this context. See browserContext.grantPermissions(permissions[, options]) for more details.
-        extra_http_headers : Optional[Dict[str, str]]
-            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
-        offline : Optional[bool]
-            Whether to emulate network being offline. Defaults to `false`.
-        http_credentials : Optional[typing.Tuple[str, str]]
-            Credentials for HTTP authentication.
-        device_scale_factor : Optional[int]
-            Specify device scale factor (can be thought of as dpr). Defaults to `1`.
-        is_mobile : Optional[bool]
-            Whether the `meta viewport` tag is taken into account and touch events are enabled. Defaults to `false`. Not supported in Firefox.
-        has_touch : Optional[bool]
-            Specifies if viewport supports touch events. Defaults to false.
-        color_scheme : Optional[Literal['dark', 'light', 'no-preference']]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See page.emulateMedia(params) for more details. Defaults to '`light`'.
-        accept_downloads : Optional[bool]
-            Whether to automatically download all the attachments. Defaults to `false` where all the downloads are canceled.
-        proxy : Optional[{"server": str, "bypass": Optional[str], "username": Optional[str], "password": Optional[str]}]
-            Network proxy settings to use with this context. Note that browser needs to be launched with the global proxy for this option to work. If all contexts override the proxy, global proxy will be never used and can be any string, for example `launch({ proxy: { server: 'per-context' } })`.
-        record_har_path : Union[str, pathlib.Path, NoneType]
-            Path on the filesystem to write the HAR file to.
-        record_har_omit_content : Optional[bool]
-            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
-        record_video_dir : Union[str, pathlib.Path, NoneType]
-            Path to the directory to put videos into.
-        record_video_size : Optional[typing.Tuple[int, int]]
-            Optional dimensions of the recorded videos. If not specified the size will be equal to `viewport`. If `viewport` is not configured explicitly the video size defaults to 1280x720. Actual picture of each page will be scaled down if necessary to fit the specified size.
-        storage_state : Union[{"cookies": Optional[List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]], "origins": Optional[List[Dict]]}, str, pathlib.Path, NoneType]
-            Populates context with given storage state. This method can be used to initialize context with logged-in information obtained via browserContext.storageState([options]). Either a path to the file with saved storage, or an object with the following fields:
-
-        Returns
-        -------
-        Page
+        expected : str
+        timeout : Union[float, None]
+            Time to retry the assertion for in milliseconds. Defaults to `5000`.
         """
+        __tracebackhide__ = True
 
-        try:
-            log_api("=> browser.new_page started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.newPage(
-                        viewport=viewport,
-                        ignoreHTTPSErrors=ignore_https_errors,
-                        javaScriptEnabled=java_script_enabled,
-                        bypassCSP=bypass_csp,
-                        userAgent=user_agent,
-                        locale=locale,
-                        timezoneId=timezone_id,
-                        geolocation=geolocation,
-                        permissions=permissions,
-                        extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                        offline=offline,
-                        httpCredentials=http_credentials,
-                        deviceScaleFactor=device_scale_factor,
-                        isMobile=is_mobile,
-                        hasTouch=has_touch,
-                        colorScheme=color_scheme,
-                        acceptDownloads=accept_downloads,
-                        defaultBrowserType=default_browser_type,
-                        proxy=proxy,
-                        recordHarPath=record_har_path,
-                        recordHarOmitContent=record_har_omit_content,
-                        recordVideoDir=record_video_dir,
-                        recordVideoSize=record_video_size,
-                        storageState=storage_state,
-                    )
-                )
-            )
-            log_api("<= browser.new_page succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser.new_page failed")
-            raise e
-
-    def close(self) -> NoneType:
-        """Browser.close
+        return mapping.from_maybe_impl(
+            self._sync(
+                self._impl_obj.not_to_match_aria_snapshot(
+                    expected=expected, timeout=to_milliseconds(timeout)
+                )
+            )
+        )
 
-        In case this browser is obtained using browser_type.launch([options]), closes the browser and all of its pages (if any were
-        opened).
-        In case this browser is obtained using browser_type.connect(params), clears all created contexts belonging to this browser
-        and disconnects from the browser server.
-        The Browser object itself is considered to be disposed and cannot be used anymore.
-        """
 
-        try:
-            log_api("=> browser.close started")
-            result = mapping.from_maybe_impl(self._sync(self._impl_obj.close()))
-            log_api("<= browser.close succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser.close failed")
-            raise e
+mapping.register(LocatorAssertionsImpl, LocatorAssertions)
 
 
-mapping.register(BrowserImpl, Browser)
+class APIResponseAssertions(SyncBase):
 
+    def to_be_ok(self) -> None:
+        """APIResponseAssertions.to_be_ok
 
-class BrowserType(SyncBase):
-    def __init__(self, obj: BrowserTypeImpl):
-        super().__init__(obj)
+        Ensures the response status code is within `200..299` range.
 
-    @property
-    def name(self) -> str:
-        """BrowserType.name
+        **Usage**
 
-        Returns browser name. For example: `'chromium'`, `'webkit'` or `'firefox'`.
+        ```py
+        import re
+        from playwright.sync_api import expect
 
-        Returns
-        -------
-        str
+        # ...
+        expect(response).to_be_ok()
+        ```
         """
-        return mapping.from_maybe_impl(self._impl_obj.name)
+        __tracebackhide__ = True
 
-    @property
-    def executable_path(self) -> str:
-        """BrowserType.executable_path
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.to_be_ok()))
 
-        A path where Playwright expects to find a bundled browser executable.
+    def not_to_be_ok(self) -> None:
+        """APIResponseAssertions.not_to_be_ok
 
-        Returns
-        -------
-        str
+        The opposite of `a_pi_response_assertions.to_be_ok()`.
         """
-        return mapping.from_maybe_impl(self._impl_obj.executablePath)
-
-    def launch(
-        self,
-        executable_path: typing.Union[str, pathlib.Path] = None,
-        args: typing.List[str] = None,
-        ignore_default_args: typing.Union[bool, typing.List[str]] = None,
-        handle_sigint: bool = None,
-        handle_sigterm: bool = None,
-        handle_sighup: bool = None,
-        timeout: int = None,
-        env: typing.Union[typing.Dict[str, typing.Union[str, int, bool]]] = None,
-        headless: bool = None,
-        devtools: bool = None,
-        proxy: "ProxySettings" = None,
-        downloads_path: typing.Union[str, pathlib.Path] = None,
-        slow_mo: int = None,
-        chromium_sandbox: bool = None,
-        firefox_user_prefs: typing.Union[
-            typing.Dict[str, typing.Union[str, int, bool]]
-        ] = None,
-    ) -> "Browser":
-        """BrowserType.launch
-
-        Returns the browser instance.
-        You can use `ignoreDefaultArgs` to filter out `--mute-audio` from default arguments:
+        __tracebackhide__ = True
 
-        **Chromium-only** Playwright can also be used to control the Chrome browser, 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` option with
-        extreme caution.
-        If Google Chrome (rather than Chromium) is preferred, a Chrome
-        Canary or Dev
-        Channel build is suggested.
-        In browser_type.launch([options]) above, any mention of Chromium also applies to Chrome.
-        See `this article` for
-        a description of the differences between Chromium and Chrome. `This article` describes
-        some differences for Linux users.
-
-        Parameters
-        ----------
-        executable_path : Union[str, pathlib.Path, NoneType]
-            Path to a browser executable to run instead of the bundled one. If `executablePath` is a relative path, then it is resolved relative to current working directory. Note that Playwright only works with the bundled Chromium, Firefox or WebKit, use at your own risk.
-        args : Optional[List[str]]
-            Additional arguments to pass to the browser instance. The list of Chromium flags can be found here.
-        ignore_default_args : Union[bool, List[str], NoneType]
-            If `true`, Playwright does not pass its own configurations args and only uses the ones from `args`. If an array is given, then filters out the given default arguments. Dangerous option; use with care. Defaults to `false`.
-        handle_sigint : Optional[bool]
-            Close the browser process on Ctrl-C. Defaults to `true`.
-        handle_sigterm : Optional[bool]
-            Close the browser process on SIGTERM. Defaults to `true`.
-        handle_sighup : Optional[bool]
-            Close the browser process on SIGHUP. Defaults to `true`.
-        timeout : Optional[int]
-            Maximum time in milliseconds to wait for the browser instance to start. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
-        env : Optional[Dict[str, Union[str, int, bool]]]
-            Specify environment variables that will be visible to the browser. Defaults to `process.env`.
-        headless : Optional[bool]
-            Whether to run browser in headless mode. More details for Chromium and Firefox. Defaults to `true` unless the `devtools` option is `true`.
-        devtools : Optional[bool]
-            **Chromium-only** Whether to auto-open a Developer Tools panel for each tab. If this option is `true`, the `headless` option will be set `false`.
-        proxy : Optional[{"server": str, "bypass": Optional[str], "username": Optional[str], "password": Optional[str]}]
-            Network proxy settings.
-        downloads_path : Union[str, pathlib.Path, NoneType]
-            If specified, accepted downloads are downloaded into this directory. Otherwise, temporary directory is created and is deleted when browser is closed.
-        slow_mo : Optional[int]
-            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going on.
-        chromium_sandbox : Optional[bool]
-            Enable Chromium sandboxing. Defaults to `false`.
-        firefox_user_prefs : Optional[Dict[str, Union[str, int, bool]]]
-            Firefox user preferences. Learn more about the Firefox user preferences at `about:config`.
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.not_to_be_ok()))
 
-        Returns
-        -------
-        Browser
-        """
 
-        try:
-            log_api("=> browser_type.launch started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.launch(
-                        executablePath=executable_path,
-                        args=args,
-                        ignoreDefaultArgs=ignore_default_args,
-                        handleSIGINT=handle_sigint,
-                        handleSIGTERM=handle_sigterm,
-                        handleSIGHUP=handle_sighup,
-                        timeout=timeout,
-                        env=mapping.to_impl(env),
-                        headless=headless,
-                        devtools=devtools,
-                        proxy=proxy,
-                        downloadsPath=downloads_path,
-                        slowMo=slow_mo,
-                        chromiumSandbox=chromium_sandbox,
-                        firefoxUserPrefs=mapping.to_impl(firefox_user_prefs),
-                    )
-                )
-            )
-            log_api("<= browser_type.launch succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_type.launch failed")
-            raise e
+mapping.register(APIResponseAssertionsImpl, APIResponseAssertions)
 
-    def launch_persistent_context(
-        self,
-        user_data_dir: typing.Union[str, pathlib.Path],
-        executable_path: typing.Union[str, pathlib.Path] = None,
-        args: typing.List[str] = None,
-        ignore_default_args: typing.Union[bool, typing.List[str]] = None,
-        handle_sigint: bool = None,
-        handle_sigterm: bool = None,
-        handle_sighup: bool = None,
-        timeout: int = None,
-        env: typing.Union[typing.Dict[str, typing.Union[str, int, bool]]] = None,
-        headless: bool = None,
-        devtools: bool = None,
-        proxy: "ProxySettings" = None,
-        downloads_path: typing.Union[str, pathlib.Path] = None,
-        slow_mo: int = None,
-        viewport: typing.Union[typing.Tuple[int, int], Literal[0]] = None,
-        ignore_https_errors: bool = None,
-        java_script_enabled: bool = None,
-        bypass_csp: bool = None,
-        user_agent: str = None,
-        locale: str = None,
-        timezone_id: str = None,
-        geolocation: "Geolocation" = None,
-        permissions: typing.List[str] = None,
-        extra_http_headers: typing.Union[typing.Dict[str, str]] = None,
-        offline: bool = None,
-        http_credentials: typing.Union[typing.Tuple[str, str]] = None,
-        device_scale_factor: int = None,
-        is_mobile: bool = None,
-        has_touch: bool = None,
-        color_scheme: Literal["dark", "light", "no-preference"] = None,
-        accept_downloads: bool = None,
-        chromium_sandbox: bool = None,
-        record_har_path: typing.Union[str, pathlib.Path] = None,
-        record_har_omit_content: bool = None,
-        record_video_dir: typing.Union[str, pathlib.Path] = None,
-        record_video_size: typing.Union[typing.Tuple[int, int]] = None,
-    ) -> "BrowserContext":
-        """BrowserType.launch_persistent_context
 
-        Returns the persistent browser context instance.
-        Launches browser that uses persistent storage located at `userDataDir` and returns the only context. Closing this
-        context will automatically close the browser.
+class Disposable(SyncContextManager):
 
-        Parameters
-        ----------
-        user_data_dir : Union[str, pathlib.Path]
-            Path to a User Data Directory, which stores browser session data like cookies and local storage. More details for Chromium and Firefox.
-        executable_path : Union[str, pathlib.Path, NoneType]
-            Path to a browser executable to run instead of the bundled one. If `executablePath` is a relative path, then it is resolved relative to current working directory. **BEWARE**: Playwright is only guaranteed to work with the bundled Chromium, Firefox or WebKit, use at your own risk.
-        args : Optional[List[str]]
-            Additional arguments to pass to the browser instance. The list of Chromium flags can be found here.
-        ignore_default_args : Union[bool, List[str], NoneType]
-            If `true`, then do not use any of the default arguments. If an array is given, then filter out the given default arguments. Dangerous option; use with care. Defaults to `false`.
-        handle_sigint : Optional[bool]
-            Close the browser process on Ctrl-C. Defaults to `true`.
-        handle_sigterm : Optional[bool]
-            Close the browser process on SIGTERM. Defaults to `true`.
-        handle_sighup : Optional[bool]
-            Close the browser process on SIGHUP. Defaults to `true`.
-        timeout : Optional[int]
-            Maximum time in milliseconds to wait for the browser instance to start. Defaults to `30000` (30 seconds). Pass `0` to disable timeout.
-        env : Optional[Dict[str, Union[str, int, bool]]]
-            Specify environment variables that will be visible to the browser. Defaults to `process.env`.
-        headless : Optional[bool]
-            Whether to run browser in headless mode. More details for Chromium and Firefox. Defaults to `true` unless the `devtools` option is `true`.
-        devtools : Optional[bool]
-            **Chromium-only** Whether to auto-open a Developer Tools panel for each tab. If this option is `true`, the `headless` option will be set `false`.
-        proxy : Optional[{"server": str, "bypass": Optional[str], "username": Optional[str], "password": Optional[str]}]
-            Network proxy settings.
-        downloads_path : Union[str, pathlib.Path, NoneType]
-            If specified, accepted downloads are downloaded into this directory. Otherwise, temporary directory is created and is deleted when browser is closed.
-        slow_mo : Optional[int]
-            Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going on. Defaults to 0.
-        viewport : Union[typing.Tuple[int, int], '0', NoneType]
-            Sets a consistent viewport for each page. Defaults to an 1280x720 viewport. `null` disables the default viewport.
-        ignore_https_errors : Optional[bool]
-            Whether to ignore HTTPS errors during navigation. Defaults to `false`.
-        java_script_enabled : Optional[bool]
-            Whether or not to enable JavaScript in the context. Defaults to `true`.
-        bypass_csp : Optional[bool]
-            Toggles bypassing page's Content-Security-Policy.
-        user_agent : Optional[str]
-            Specific user agent to use in this context.
-        locale : Optional[str]
-            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.
-        timezone_id : Optional[str]
-            Changes the timezone of the context. See ICU’s `metaZones.txt` for a list of supported timezone IDs.
-        geolocation : Optional[{"latitude": float, "longitude": float, "accuracy": Optional[float]}]
-        permissions : Optional[List[str]]
-            A list of permissions to grant to all pages in this context. See browserContext.grantPermissions(permissions[, options]) for more details.
-        extra_http_headers : Optional[Dict[str, str]]
-            An object containing additional HTTP headers to be sent with every request. All header values must be strings.
-        offline : Optional[bool]
-            Whether to emulate network being offline. Defaults to `false`.
-        http_credentials : Optional[typing.Tuple[str, str]]
-            Credentials for HTTP authentication.
-        device_scale_factor : Optional[int]
-            Specify device scale factor (can be thought of as dpr). Defaults to `1`.
-        is_mobile : Optional[bool]
-            Whether the `meta viewport` tag is taken into account and touch events are enabled. Defaults to `false`. Not supported in Firefox.
-        has_touch : Optional[bool]
-            Specifies if viewport supports touch events. Defaults to false.
-        color_scheme : Optional[Literal['dark', 'light', 'no-preference']]
-            Emulates `'prefers-colors-scheme'` media feature, supported values are `'light'`, `'dark'`, `'no-preference'`. See page.emulateMedia(params) for more details. Defaults to '`light`'.
-        accept_downloads : Optional[bool]
-            Whether to automatically download all the attachments. Defaults to `false` where all the downloads are canceled.
-        chromium_sandbox : Optional[bool]
-            Enable Chromium sandboxing. Defaults to `true`.
-        record_har_path : Union[str, pathlib.Path, NoneType]
-            Path on the filesystem to write the HAR file to.
-        record_har_omit_content : Optional[bool]
-            Optional setting to control whether to omit request content from the HAR. Defaults to `false`.
-        record_video_dir : Union[str, pathlib.Path, NoneType]
-            Path to the directory to put videos into.
-        record_video_size : Optional[typing.Tuple[int, int]]
-            Optional dimensions of the recorded videos. If not specified the size will be equal to `viewport`. If `viewport` is not configured explicitly the video size defaults to 1280x720. Actual picture of each page will be scaled down if necessary to fit the specified size.
+    def dispose(self) -> None:
+        """Disposable.dispose
 
-        Returns
-        -------
-        BrowserContext
+        Removes the associated resource. For example, removes the init script installed via `page.add_init_script()`
+        or `browser_context.add_init_script()`.
         """
 
-        try:
-            log_api("=> browser_type.launch_persistent_context started")
-            result = mapping.from_impl(
-                self._sync(
-                    self._impl_obj.launchPersistentContext(
-                        userDataDir=user_data_dir,
-                        executablePath=executable_path,
-                        args=args,
-                        ignoreDefaultArgs=ignore_default_args,
-                        handleSIGINT=handle_sigint,
-                        handleSIGTERM=handle_sigterm,
-                        handleSIGHUP=handle_sighup,
-                        timeout=timeout,
-                        env=mapping.to_impl(env),
-                        headless=headless,
-                        devtools=devtools,
-                        proxy=proxy,
-                        downloadsPath=downloads_path,
-                        slowMo=slow_mo,
-                        viewport=viewport,
-                        ignoreHTTPSErrors=ignore_https_errors,
-                        javaScriptEnabled=java_script_enabled,
-                        bypassCSP=bypass_csp,
-                        userAgent=user_agent,
-                        locale=locale,
-                        timezoneId=timezone_id,
-                        geolocation=geolocation,
-                        permissions=permissions,
-                        extraHTTPHeaders=mapping.to_impl(extra_http_headers),
-                        offline=offline,
-                        httpCredentials=http_credentials,
-                        deviceScaleFactor=device_scale_factor,
-                        isMobile=is_mobile,
-                        hasTouch=has_touch,
-                        colorScheme=color_scheme,
-                        acceptDownloads=accept_downloads,
-                        chromiumSandbox=chromium_sandbox,
-                        recordHarPath=record_har_path,
-                        recordHarOmitContent=record_har_omit_content,
-                        recordVideoDir=record_video_dir,
-                        recordVideoSize=record_video_size,
-                    )
-                )
-            )
-            log_api("<= browser_type.launch_persistent_context succeded")
-            return result
-        except Exception as e:
-            log_api("<= browser_type.launch_persistent_context failed")
-            raise e
-
-
-mapping.register(BrowserTypeImpl, BrowserType)
-
-
-class Playwright(SyncBase):
-    def __init__(self, obj: PlaywrightImpl):
-        super().__init__(obj)
-
-    @property
-    def chromium(self) -> "BrowserType":
-        return mapping.from_impl(self._impl_obj.chromium)
-
-    @property
-    def firefox(self) -> "BrowserType":
-        return mapping.from_impl(self._impl_obj.firefox)
-
-    @property
-    def webkit(self) -> "BrowserType":
-        return mapping.from_impl(self._impl_obj.webkit)
-
-    @property
-    def selectors(self) -> "Selectors":
-        return mapping.from_impl(self._impl_obj.selectors)
-
-    @property
-    def devices(self) -> typing.Dict[str, "DeviceDescriptor"]:
-        return mapping.from_impl_dict(self._impl_obj.devices)
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.dispose()))
 
-    def stop(self) -> NoneType:
+    def close(self) -> None:
 
-        try:
-            log_api("=> playwright.stop started")
-            result = mapping.from_maybe_impl(self._impl_obj.stop())
-            log_api("<= playwright.stop succeded")
-            return result
-        except Exception as e:
-            log_api("<= playwright.stop failed")
-            raise e
+        return mapping.from_maybe_impl(self._sync(self._impl_obj.close()))
 
 
-mapping.register(PlaywrightImpl, Playwright)
+mapping.register(DisposableImpl, Disposable)
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 000000000..7ccb314f5
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,98 @@
+[build-system]
+requires = ["setuptools==80.9.0", "setuptools-scm==9.2.2", "wheel==0.45.1", "auditwheel==6.4.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "playwright"
+description = "A high-level API to automate web browsers"
+authors = [
+    {name = "Microsoft Corporation"}
+]
+readme = "README.md"
+license = "Apache-2.0"
+dynamic = ["version"]
+requires-python = ">=3.9"
+# Please when changing dependencies run the following commands to update requirements.txt:
+# - pip install uv==0.5.4
+# - uv pip compile pyproject.toml -o requirements.txt
+dependencies = [
+    "pyee>=13,<14",
+    "greenlet>=3.1.1,<4.0.0"
+]
+classifiers = [
+    "Topic :: Software Development :: Testing",
+    "Topic :: Internet :: WWW/HTTP :: Browsers",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+homepage = "https://github.com/Microsoft/playwright-python"
+"Release notes" = "https://github.com/microsoft/playwright-python/releases"
+
+[project.scripts]
+playwright = "playwright.__main__:main"
+
+[project.entry-points.pyinstaller40]
+hook-dirs = "playwright._impl.__pyinstaller:get_hook_dirs"
+
+[tool.setuptools]
+packages = [
+    "playwright",
+    "playwright.async_api",
+    "playwright.sync_api",
+    "playwright._impl",
+    "playwright._impl.__pyinstaller",
+]
+include-package-data = true
+
+[tool.setuptools_scm]
+version_file = "playwright/_repo_version.py"
+
+[tool.pytest.ini_options]
+addopts = "-Wall -rsx -vv -s"
+markers = [
+    "skip_browser",
+    "only_browser",
+    "skip_platform",
+    "only_platform"
+]
+junit_family = "xunit2"
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
+asyncio_default_test_loop_scope = "session"
+
+[tool.mypy]
+ignore_missing_imports = true
+python_version = "3.9"
+warn_unused_ignores = false
+warn_redundant_casts = true
+warn_unused_configs = true
+check_untyped_defs = true
+disallow_untyped_defs = true
+no_implicit_optional = false
+exclude = [
+    "build/",
+    "env/",
+]
+
+[tool.isort]
+profile = "black"
+
+[tool.pyright]
+include = ["playwright", "tests", "scripts"]
+exclude = ["**/node_modules", "**/__pycache__", "**/.*", "./build"]
+pythonVersion = "3.9"
+reportMissingImports = false
+reportTypedDictNotRequiredAccess = false
+reportCallInDefaultInitializer = true
+reportOptionalSubscript = false
+reportUnboundVariable = false
+strictParameterNoneValue = false
+reportIncompatibleVariableOverride = false
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 000000000..75d362fe8
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,8 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile pyproject.toml -o requirements.txt
+greenlet==3.2.4
+    # via playwright (pyproject.toml)
+pyee==13.0.0
+    # via playwright (pyproject.toml)
+typing-extensions==4.14.1
+    # via pyee
diff --git a/scripts/documentation_provider.py b/scripts/documentation_provider.py
index 2da70f062..ed4a70e93 100644
--- a/scripts/documentation_provider.py
+++ b/scripts/documentation_provider.py
@@ -13,44 +13,24 @@
 # limitations under the License.
 
 import json
+import pathlib
 import re
 import subprocess
 from sys import stderr
-from typing import (  # type: ignore
-    Any,
-    Dict,
-    List,
-    Set,
-    Union,
-    get_args,
-    get_origin,
-    get_type_hints,
-)
+from typing import Any, Dict, List, Set, Union, get_args, get_origin, get_type_hints
+from urllib.parse import urljoin
 
 from playwright._impl._helper import to_snake_case
 
 enum_regex = r"^\"[^\"]+\"(?:\|\"[^\"]+\")+$"
 union_regex = r"^[^\|]+(?:\|[^\|]+)+$"
 
-exceptions = {
-    "Route.fulfill(path=)": {
-        "doc": "Optional[str]",
-        "code": "Union[str, pathlib.Path, NoneType]",
-    },
-    "Browser.newContext(viewport=)": {
-        "doc": 'Optional[{"width": int, "height": int}]',
-        "code": 'Union[{"width": int, "height": int}, \'0\', NoneType]',
-    },
-    "Browser.newPage(viewport=)": {
-        "doc": 'Optional[{"width": int, "height": int}]',
-        "code": 'Union[{"width": int, "height": int}, \'0\', NoneType]',
-    },
-}
-
 
 class DocumentationProvider:
-    def __init__(self) -> None:
+    def __init__(self, is_async: bool) -> None:
+        self.is_async = is_async
         self.api: Any = {}
+        self.links: Dict[str, str] = {}
         self.printed_entries: List[str] = []
         process_output = subprocess.run(
             ["python", "-m", "playwright", "print-api-json"],
@@ -59,74 +39,116 @@ def __init__(self) -> None:
         )
         self.api = json.loads(process_output.stdout)
         self.errors: Set[str] = set()
-        self._patch_descriptions()
-
-    method_name_rewrites: Dict[str, str] = {
-        "continue_": "continue",
-        "evalOnSelector": "$eval",
-        "evalOnSelectorAll": "$$eval",
-        "querySelector": "$",
-        "querySelectorAll": "$$",
-    }
-
-    def _patch_descriptions(self) -> None:
-        map: Dict[str, str] = {}
-        for class_name in self.api:
-            clazz = self.api[class_name]
-            js_class = ""
-            if class_name.startswith("JS"):
-                js_class = "jsHandle"
-            if class_name.startswith("CDP"):
-                js_class = "cdpSession"
-            else:
-                js_class = class_name[0:1].lower() + class_name[1:]
-            for method_name in clazz["methods"]:
-                camel_case = js_class + "." + method_name
-                snake_case = (
-                    to_snake_case(class_name) + "." + to_snake_case(method_name)
-                )
-                map[camel_case] = snake_case
-
-        for [name, value] in map.items():
-            for class_name in self.api:
-                clazz = self.api[class_name]
-                for method_name in clazz["methods"]:
-                    method = clazz["methods"][method_name]
-                    if "comment" in method:
-                        method["comment"] = method["comment"].replace(name, value)
-                    if "args" in method:
-                        for _, arg in method["args"].items():
-                            if "comment" in arg:
-                                arg["comment"] = arg["comment"].replace(name, value)
+        self.class_aliases: Dict[str, str] = {
+            "Disposable": "AsyncContextManager" if is_async else "SyncContextManager",
+            "DisposableStub": (
+                "AsyncContextManager" if is_async else "SyncContextManager"
+            ),
+        }
+        self._patch_case()
+
+    def _patch_case(self) -> None:
+        self.classes = {}
+        for clazz in self.api:
+            if not works_for_python(clazz) and clazz["name"] not in self.class_aliases:
+                continue
+            members = {}
+            self.classes[clazz["name"]] = clazz
+            events = []
+            for member in clazz["members"]:
+                if not works_for_python(member):
+                    continue
+                member_name = member["name"]
+                new_name = name_or_alias(member)
+                self._add_link(member["kind"], clazz["name"], member_name, new_name)
+
+                if member["kind"] == "event":
+                    events.append(member)
+                else:
+                    new_name = to_snake_case(new_name)
+                    member["name"] = new_name
+                    members[new_name] = member
+                apply_type_or_override(member)
+
+                if "args" in member:
+                    args = {}
+                    for arg in member["args"]:
+                        if not works_for_python(arg):
+                            continue
+                        if arg["name"] == "options":
+                            for option in arg["type"]["properties"]:
+                                if not works_for_python(option):
+                                    continue
+                                option = self_or_override(option)
+                                option_name = to_snake_case(name_or_alias(option))
+                                option["name"] = option_name
+                                option["required"] = False
+                                args[option_name] = option
+                        else:
+                            arg = self_or_override(arg)
+                            arg_name = to_snake_case(name_or_alias(arg))
+                            arg["name"] = arg_name
+                            args[arg_name] = arg
+
+                    member["args"] = args
+
+            clazz["members"] = members
+            clazz["events"] = events
+
+    def _add_link(self, kind: str, clazz: str, member: str, alias: str) -> None:
+        match = re.match(r"(JS|CDP|[A-Z])([^.]+)", clazz)
+        if not match:
+            raise Exception("Invalid class " + clazz)
+        var_name = to_snake_case(f"{match.group(1).lower()}{match.group(2)}")
+        new_name = to_snake_case(alias)
+        if kind == "event":
+            new_name = new_name.lower()
+            self.links[f"[`event: {clazz}.{member}`]"] = (
+                f"`{var_name}.on('{new_name}')`"
+            )
+        elif kind == "property":
+            self.links[f"[`property: {clazz}.{member}`]"] = f"`{var_name}.{new_name}`"
+        else:
+            self.links[f"[`method: {clazz}.{member}`]"] = f"`{var_name}.{new_name}()`"
 
     def print_entry(
-        self, class_name: str, method_name: str, signature: Dict[str, Any] = None
+        self,
+        class_name: str,
+        method_name: str,
+        signature: Dict[str, Any] = None,
+        is_property: bool = False,
     ) -> None:
-        if class_name in ["BindingCall", "Playwright"] or method_name in [
+        if class_name in ["BindingCall"] or method_name in [
             "pid",
-            "_add_event_handler",
-            "remove_listener",
         ]:
             return
         original_method_name = method_name
-        if method_name in self.method_name_rewrites:
-            method_name = self.method_name_rewrites[method_name]
         self.printed_entries.append(f"{class_name}.{method_name}")
-        if class_name == "JSHandle":
-            self.printed_entries.append(f"ElementHandle.{method_name}")
-        clazz = self.api[class_name]
-        super_clazz = self.api.get(clazz.get("extends"))
-        method = (
-            clazz["methods"].get(method_name)
-            or clazz["properties"].get(method_name)
-            or (super_clazz and super_clazz["methods"].get(method_name))
-        )
+        clazz = self.classes[class_name]
+        method = clazz["members"].get(method_name)
+        if not method and "extends" in clazz:
+            superclass = self.classes.get(clazz["extends"])
+            if superclass:
+                method = superclass["members"].get(method_name)
         fqname = f"{class_name}.{method_name}"
 
         if not method:
             self.errors.add(f"Method not documented: {fqname}")
             return
 
+        doc_is_property = (
+            not method.get("async") and not len(method["args"]) and "type" in method
+        )
+        if (
+            method["name"].startswith("is_")
+            or method["name"].startswith("as_")
+            or method["name"] == "connect_to_server"
+        ):
+            doc_is_property = False
+        if doc_is_property != is_property:
+            self.errors.add(f"Method vs property mismatch: {fqname}")
+            return
+
         indent = " " * 8
         print(f'{indent}"""{class_name}.{to_snake_case(original_method_name)}')
         if method.get("comment"):
@@ -137,71 +159,33 @@ def print_entry(
 
         # Collect a list of all names, flatten options.
         args = method["args"]
-        args_with_expanded_options: Dict[str, Any] = dict()
-        for name, value in args.items():
-            expand = False
-            if name == "options":
-                expand = True
-            if fqname == "Page.frame" and name == "frameSelector":
-                expand = True
-            if ".addStyleTag" in fqname and name == "style":
-                expand = True
-            if ".addScriptTag" in fqname and name == "script":
-                expand = True
-            if fqname == "Page.emulateMedia" and name == "params":
-                expand = True
-            if fqname == "Route.fulfill" and name == "response":
-                expand = True
-            if fqname == "Route.continue" and name == "overrides":
-                expand = True
-            if fqname == "Page.setViewportSize" and name == "viewportSize":
-                expand = True
-            if fqname == "BrowserContext.setGeolocation" and name == "geolocation":
-                expand = True
-            if expand:
-                for opt_name, opt_value in args[name]["type"]["properties"].items():
-                    if opt_name == "recordHar" or opt_name == "recordVideo":
-                        for sub_name, sub_value in opt_value["type"][
-                            "properties"
-                        ].items():
-                            args_with_expanded_options[
-                                opt_name + sub_name[0:1].upper() + sub_name[1:]
-                            ] = sub_value
-                    else:
-                        args_with_expanded_options[opt_name] = opt_value
-            else:
-                args_with_expanded_options[name] = value
-
         if signature and signature_no_return:
             print("")
             print("        Parameters")
             print("        ----------")
             for [name, value] in signature.items():
+                name = to_snake_case(name)
                 if name == "return":
                     continue
-                if name == "force_expr":
-                    continue
                 original_name = name
-                name = self.rewrite_param_name(fqname, method_name, name)
-                doc_value = args_with_expanded_options.get(name)
-                if name in args_with_expanded_options:
-                    del args_with_expanded_options[name]
+                doc_value = args.get(name)
+                if name in args:
+                    del args[name]
                 if not doc_value:
                     self.errors.add(f"Parameter not documented: {fqname}({name}=)")
                 else:
-                    code_type = self.serialize_python_type(value)
+                    code_type = self.serialize_python_type(value, "in")
 
                     print(f"{indent}{to_snake_case(original_name)} : {code_type}")
                     if doc_value.get("comment"):
                         print(
-                            f"{indent}    {self.indent_paragraph(doc_value['comment'], f'{indent}    ')}"
+                            f"{indent}    {self.indent_paragraph(self.render_links(doc_value['comment']), f'{indent}    ')}"
                         )
-                    if original_name == "expression":
-                        print(f"{indent}force_expr : bool")
+                    if doc_value.get("deprecated"):
                         print(
-                            f"{indent}    Whether to treat given expression as JavaScript evaluate expression, even though it looks like an arrow function"
+                            f"{indent}    Deprecated: {self.render_links(doc_value['deprecated'])}"
                         )
-                    self.compare_types(code_type, doc_value, f"{fqname}({name}=)")
+                    self.compare_types(code_type, doc_value, f"{fqname}({name}=)", "in")
         if (
             signature
             and "return" in signature
@@ -209,22 +193,105 @@ def print_entry(
         ):
             value = signature["return"]
             doc_value = method
-            self.compare_types(value, doc_value, f"{fqname}(return=)")
+            self.compare_types(value, doc_value, f"{fqname}(return=)", "out")
             print("")
             print("        Returns")
             print("        -------")
-            print(f"        {self.serialize_python_type(value)}")
-            if method.get("returnComment"):
-                print(
-                    f"            {self.indent_paragraph(method['returnComment'], '              ')}"
-                )
+            print(f"        {self.serialize_python_type(value, 'out')}")
         print(f'{indent}"""')
 
-        for name in args_with_expanded_options:
+        for name in args:
+            if args[name].get("deprecated"):
+                continue
             self.errors.add(
                 f"Parameter not implemented: {class_name}.{method_name}({name}=)"
             )
 
+    def print_events(self, class_name: str) -> None:
+        clazz = self.classes[class_name]
+        events = clazz["events"]
+        if events:
+            doc = []
+            for event_type in ["on", "once"]:
+                return_type = (
+                    "typing.Union[typing.Awaitable[None], None]"
+                    if self.is_async
+                    else "None"
+                )
+                for event in events:
+                    func_arg = self.serialize_doc_type(event["type"], "")
+                    if func_arg.startswith("{"):
+                        func_arg = "typing.Dict"
+                    if "Union[" in func_arg:
+                        func_arg = func_arg.replace("Union[", "typing.Union[")
+                    doc.append("    @typing.overload")
+                    doc.append(
+                        f"    def {event_type}(self, event: Literal['{event['name'].lower()}'], f: typing.Callable[['{func_arg}'], '{return_type}']) -> None:"
+                    )
+                    doc.append(
+                        f'        """{self.beautify_method_comment(event["comment"], " " * 8)}"""'
+                    )
+                if len(events) == 1:
+                    doc.append("    @typing.overload")
+                    doc.append(
+                        f"    def {event_type}(self, event: str, f: typing.Callable[...,{return_type}]) -> None: ..."
+                    )
+                    doc.append("")
+                doc.append(
+                    f"    def {event_type}(self, event: str, f: typing.Callable[...,{return_type}]) -> None:"
+                )
+                doc.append(f"        return super().{event_type}(event=event,f=f)")
+            print("\n".join(doc))
+
+    def print_event_overloads(self, class_name: str, method_name: str) -> None:
+        """Emit ``@typing.overload`` stubs for ``expect_event`` / ``wait_for_event``
+        keyed on ``Literal`` event names with their payload types from api.json,
+        so pyright/mypy can narrow the return type at call sites.
+        Must be called right before the implementation signature is emitted.
+        """
+        if class_name not in self.classes:
+            return
+        events = self.classes[class_name].get("events") or []
+        if not events:
+            return
+        is_expect = method_name == "expect_event"
+        async_prefix = "async " if not is_expect and self.is_async else ""
+        if is_expect:
+            ctx_mgr = (
+                "AsyncEventContextManager" if self.is_async else "EventContextManager"
+            )
+        for event in events:
+            payload = self.serialize_doc_type(event["type"], "")
+            if payload.startswith("{"):
+                payload = "typing.Dict"
+            if "Union[" in payload:
+                payload = payload.replace("Union[", "typing.Union[")
+            return_type = f'{ctx_mgr}["{payload}"]' if is_expect else f'"{payload}"'
+            event_literal = event["name"].lower()
+            print("    @typing.overload")
+            print(f"    {async_prefix}def {method_name}(")
+            print("        self,")
+            print(f'        event: typing.Literal["{event_literal}"],')
+            print(
+                f'        predicate: typing.Optional[typing.Callable[["{payload}"], bool]] = None,'
+            )
+            print("        *,")
+            print("        timeout: typing.Optional[float] = None,")
+            print(f"    ) -> {return_type}: ...")
+            print("")
+        # Catch-all overload for non-literal event names — keeps pyright happy
+        # with `event: str` callers without falling through to `Unknown`.
+        catchall_return = f"{ctx_mgr}[typing.Any]" if is_expect else "typing.Any"
+        print("    @typing.overload")
+        print(f"    {async_prefix}def {method_name}(")
+        print("        self,")
+        print("        event: str,")
+        print("        predicate: typing.Optional[typing.Callable[..., bool]] = None,")
+        print("        *,")
+        print("        timeout: typing.Optional[float] = None,")
+        print(f"    ) -> {catchall_return}: ...")
+        print("")
+
     def indent_paragraph(self, p: str, indent: str) -> str:
         lines = p.split("\n")
         result = [lines[0]]
@@ -233,80 +300,142 @@ def indent_paragraph(self, p: str, indent: str) -> str:
         return "\n".join(result)
 
     def beautify_method_comment(self, comment: str, indent: str) -> str:
+        comment = self.filter_out_redundant_python_code_snippets(comment)
+        comment = comment.replace("\\", "\\\\")
+        comment = comment.replace('"', '\\"')
         lines = comment.split("\n")
         result = []
-        in_example = False
+        skip_example = False
         last_was_blank = True
         for line in lines:
             if not line.strip():
                 last_was_blank = True
                 continue
-            if line.strip() == "```js":
-                in_example = True
-            if not in_example:
+            match = re.match(r"\s*```(.+)", line)
+            if match:
+                lang = match[1]
+                if lang in ["html", "yml", "sh", "py", "python"]:
+                    skip_example = False
+                elif lang == "python " + ("async" if self.is_async else "sync"):
+                    skip_example = False
+                    line = "```py"
+                else:
+                    skip_example = True
+            if not skip_example:
                 if last_was_blank:
                     last_was_blank = False
                     result.append("")
-                result.append(line)
-            if line.strip() == "```":
-                in_example = False
-        return self.indent_paragraph("\n".join(result), indent)
+                result.append(self.render_links(line))
+            if skip_example and line.strip() == "```":
+                skip_example = False
+        comment = self.indent_paragraph("\n".join(result), indent)
+        return self.resolve_playwright_dev_links(comment)
+
+    def filter_out_redundant_python_code_snippets(self, comment: str) -> str:
+        groups = []
+        current_group = []
+        lines = comment.split("\n")
+        start_pos = None
+        for i in range(len(lines)):
+            line = lines[i].strip()
+            if line.startswith("```py"):
+                start_pos = i
+            elif line == "```" and start_pos is not None:
+                current_group.append((start_pos, i))
+                start_pos = None
+            elif (
+                (line.startswith("```") or i == len(lines) - 1)
+                and start_pos is None
+                and len(current_group) == 2
+            ):
+                groups.append(current_group)
+                current_group = []
+        groups.reverse()
+        for first_pos, second_pos in groups:
+            # flake8: noqa: E203
+            second_snippet_is_async = "await" in lines[second_pos[0] : second_pos[1]]
+            if second_snippet_is_async == self.is_async:
+                # flake8: noqa: E203
+                del lines[first_pos[0] : first_pos[1] + 1]
+            else:
+                # flake8: noqa: E203
+                del lines[second_pos[0] : second_pos[1] + 1]
+        return "\n".join(lines)
+
+    def resolve_playwright_dev_links(self, comment: str) -> str:
+        def replace_callback(m: re.Match) -> str:
+            link_text = m.group(1)
+            link_href = m.group(2)
+            resolved = urljoin(
+                "https://playwright.dev/python/docs/api/", link_href.replace(".md", "")
+            )
+            return f"[{link_text}]({resolved})"
+
+        # matches against internal markdown links which start with '.'/'..'
+        # e.g. [Playwright](./class-foobar.md)
+        return re.sub(r"\[([^\]]+)\]\((\.[^\)]+)\)", replace_callback, comment)
+
+    def render_links(self, comment: str) -> str:
+        for [old, new] in self.links.items():
+            comment = comment.replace(old, new)
+        return comment
 
     def make_optional(self, text: str) -> str:
         if text.startswith("Union["):
-            return text[:-1] + ", NoneType]"
-        if text.startswith("Optional["):
-            return text
-        return f"Optional[{text}]"
+            if text.endswith("None]"):
+                return text
+            return text[:-1] + ", None]"
+        return f"Union[{text}, None]"
 
-    def compare_types(self, value: Any, doc_value: Any, fqname: str) -> None:
+    def compare_types(
+        self, value: Any, doc_value: Any, fqname: str, direction: str
+    ) -> None:
         if "(arg=)" in fqname or "(pageFunction=)" in fqname:
             return
-        code_type = self.serialize_python_type(value)
-        doc_type = self.serialize_doc_type(
-            doc_value["type"]["name"],
-            fqname,
-            doc_value["type"],
-        )
+        code_type = self.serialize_python_type(value, direction)
+        doc_type = self.serialize_doc_type(doc_value["type"], direction)
         if not doc_value["required"]:
             doc_type = self.make_optional(doc_type)
-        if (
-            fqname in exceptions
-            and exceptions[fqname]["doc"] == doc_type
-            and exceptions[fqname]["code"] == code_type
-        ):
-            return
 
         if doc_type != code_type:
+            if (
+                code_type in self.class_aliases
+                and doc_type == self.class_aliases[code_type]
+            ):
+                return
             self.errors.add(
                 f"Parameter type mismatch in {fqname}: documented as {doc_type}, code has {code_type}"
             )
 
-    def serialize_python_type(self, value: Any) -> str:
+    def serialize_python_type(self, value: Any, direction: str) -> str:
         str_value = str(value)
         if isinstance(value, list):
-            return f"[{', '.join(list(map(lambda a: self.serialize_python_type(a), value)))}]"
-        if str_value == "<class 'playwright._impl._types.Error'>":
+            return f"[{', '.join(list(map(lambda a: self.serialize_python_type(a, direction), value)))}]"
+        if str_value == "<class 'playwright._impl._errors.Error'>":
             return "Error"
+        if str_value == "<class 'NoneType'>":
+            return "None"
+        if str_value == "<class 'datetime.datetime'>":
+            return "datetime.datetime"
         match = re.match(r"^<class '((?:pathlib\.)?\w+)'>$", str_value)
         if match:
             return match.group(1)
-        match = re.match(r"^<class 'playwright\._impl\.[\w_]+\.([\w]+)'>$", str_value)
-        if match and "_api_structures" not in str_value:
-            if match.group(1) == "FilePayload":
-                return "Dict"
-            if match.group(1) == "FloatRect":
-                return '{"x": float, "y": float, "width": float, "height": float}'
-            if match.group(1) == "Geolocation":
-                return '{"latitude": float, "longitude": float, "accuracy": Optional[float]}'
-            if match.group(1) == "PdfMargins":
-                return '{"top": Union[str, int, NoneType], "right": Union[str, int, NoneType], "bottom": Union[str, int, NoneType], "left": Union[str, int, NoneType]}'
-            if match.group(1) == "ProxySettings":
-                return '{"server": str, "bypass": Optional[str], "username": Optional[str], "password": Optional[str]}'
-            if match.group(1) == "SourceLocation":
-                return '{"url": str, "lineNumber": int, "columnNumber": int}'
-
-            return match.group(1)
+        if str_value == str(pathlib.Path):
+            return "pathlib.Path"
+        match = re.match(
+            r"playwright._impl._event_context_manager.EventContextManagerImpl\[playwright._impl.[^.]+.(.*)\]",
+            str_value,
+        )
+        if match:
+            return "EventContextManager[" + match.group(1) + "]"
+        match = re.match(r"^<class 'playwright\._impl\.[\w_]+\.([^']+)'>$", str_value)
+        if match and "_api_structures" not in str_value and "_errors" not in str_value:
+            if match.group(1) == "EventContextManagerImpl":
+                return "EventContextManager"
+            class_name = match.group(1)
+            if class_name in self.class_aliases:
+                return self.class_aliases[class_name]
+            return class_name
 
         match = re.match(r"^typing\.(\w+)$", str_value)
         if match:
@@ -322,159 +451,152 @@ def serialize_python_type(self, value: Any) -> str:
         if hints:
             signature: List[str] = []
             for [name, value] in hints.items():
-                signature.append(f'"{name}": {self.serialize_python_type(value)}')
+                signature.append(
+                    f"{name}: {self.serialize_python_type(value, direction)}"
+                )
             return f"{{{', '.join(signature)}}}"
         if origin == Union:
             args = get_args(value)
-            if len(args) == 2 and "None" in str(args[1]):
-                return self.make_optional(self.serialize_python_type(args[0]))
-            return f"Union[{', '.join(list(map(lambda a: self.serialize_python_type(a), args)))}]"
+            if not self.is_async:
+                # Sync API doesn't accept awaitable callbacks; drop the
+                # Awaitable arm so docstring types match the sync signature.
+                args = tuple(
+                    a
+                    for a in args
+                    if str(get_origin(a)) != "<class 'collections.abc.Awaitable'>"
+                )
+                if len(args) == 1:
+                    return self.serialize_python_type(args[0], direction)
+            if len(args) == 2 and str(args[1]) == "<class 'NoneType'>":
+                return self.make_optional(
+                    self.serialize_python_type(args[0], direction)
+                )
+            ll = list(map(lambda a: self.serialize_python_type(a, direction), args))
+            ll.sort(key=lambda item: "}" if item == "None" else item)
+            return f"Union[{', '.join(ll)}]"
         if str(origin) == "<class 'dict'>":
             args = get_args(value)
-            return f"Dict[{', '.join(list(map(lambda a: self.serialize_python_type(a), args)))}]"
+            return f"Dict[{', '.join(list(map(lambda a: self.serialize_python_type(a, direction), args)))}]"
+        if str(origin) == "<class 'collections.abc.Sequence'>":
+            args = get_args(value)
+            return f"Sequence[{', '.join(list(map(lambda a: self.serialize_python_type(a, direction), args)))}]"
         if str(origin) == "<class 'list'>":
             args = get_args(value)
-            return f"List[{', '.join(list(map(lambda a: self.serialize_python_type(a), args)))}]"
+            list_type = "Sequence" if direction == "in" else "List"
+            return f"{list_type}[{', '.join(list(map(lambda a: self.serialize_python_type(a, direction), args)))}]"
         if str(origin) == "<class 'collections.abc.Callable'>":
             args = get_args(value)
-            return f"Callable[{', '.join(list(map(lambda a: self.serialize_python_type(a), args)))}]"
+            return f"Callable[{', '.join(list(map(lambda a: self.serialize_python_type(a, direction), args)))}]"
+        if str(origin) == "<class 're.Pattern'>":
+            return "Pattern[str]"
         if str(origin) == "typing.Literal":
             args = get_args(value)
             if len(args) == 1:
-                return "'" + self.serialize_python_type(args[0]) + "'"
+                return '"' + self.serialize_python_type(args[0], direction) + '"'
             body = ", ".join(
-                list(map(lambda a: "'" + self.serialize_python_type(a) + "'", args))
+                list(
+                    map(
+                        lambda a: '"' + self.serialize_python_type(a, direction) + '"',
+                        args,
+                    )
+                )
             )
-            return f"Literal[{body}]"
+            return f"Union[{body}]"
         return str_value
 
-    def serialize_doc_type(
-        self, type_name: Any, fqname: str, doc_type: Any = None
-    ) -> str:
-        type_name = re.sub(r"^Promise<(.*)>$", r"\1", type_name)
-
-        if type_name == "string":
-            return "str"
-
-        if type_name == "Buffer":
-            return "bytes"
+    def serialize_doc_type(self, type: Any, direction: str) -> str:
+        result = self.inner_serialize_doc_type(type, direction)
+        return result
+
+    def inner_serialize_doc_type(self, type: Any, direction: str) -> str:
+        if type["name"] == "Promise":
+            if "templates" not in type:
+                return "Any"
+            type = type["templates"][0]
+
+        if "union" in type:
+            ll = [self.serialize_doc_type(t, direction) for t in type["union"]]
+            ll.sort(key=lambda item: "}" if item == "None" else item)
+            for i in range(len(ll)):
+                if ll[i].startswith("Union["):
+                    ll[i] = ll[i][6:-1]
+            return f"Union[{', '.join(ll)}]"
+
+        type_name = type["name"]
+        if type_name == "path":
+            if direction == "in":
+                return "Union[pathlib.Path, str]"
+            else:
+                return "pathlib.Path"
 
-        if type_name == "Array":
-            return "List"
+        if type_name == "function" and "args" not in type:
+            return "Callable"
 
+        if type_name == "function":
+            return_type = "Any"
+            if type.get("returnType"):
+                return_type = self.serialize_doc_type(type["returnType"], direction)
+            return f"Callable[[{', '.join(self.serialize_doc_type(t, direction) for t in type['args'])}], {return_type}]"
+
+        if "templates" in type:
+            base = type_name
+            if type_name == "Array":
+                base = "Sequence" if direction == "in" else "List"
+            if type_name == "Object" or type_name == "Map":
+                base = "Dict"
+            return f"{base}[{', '.join(self.serialize_doc_type(t, direction) for t in type['templates'])}]"
+
+        if type_name == "Object" and "properties" in type:
+            items = []
+            for p in type["properties"]:
+                items.append(
+                    (p["name"])
+                    + ": "
+                    + (
+                        self.serialize_doc_type(p["type"], direction)
+                        if p["required"]
+                        else self.make_optional(
+                            self.serialize_doc_type(p["type"], direction)
+                        )
+                    )
+                )
+            return f"{{{', '.join(items)}}}"
         if type_name == "boolean":
             return "bool"
-
-        if type_name == "number":
-            if fqname == "Request.timing(return=)" or "ResourceTiming" in fqname:
-                return "float"
-            if ("Mouse" in fqname or "Touchscreen" in fqname) and (
-                "(x=)" in fqname or "(y=)" in fqname
-            ):
-                return "float"
-            if (
-                "(position=)" in fqname
-                or "(geolocation=)" in fqname
-                or ".boundingBox(" in fqname
-            ):
-                return "float"
-            if "screenshot(clip=)" in fqname:
-                return "float"
-            if fqname == "Page.pdf(width=)" or fqname == "Page.pdf(height=)":
-                return "float"
-            if fqname.startswith("BrowserContext.setGeolocation"):
-                return "float"
+        if type_name == "long":
             return "int"
-
-        if type_name == "Serializable":
+        if type_name.lower() == "string":
+            return "str"
+        if type_name == "any" or type_name == "unknown" or type_name == "Serializable":
             return "Any"
-
-        if type_name == "Object" or type_name == "?Object":
-            intermediate = "Dict"
-            if doc_type and "properties" in doc_type and len(doc_type["properties"]):
-                signature: List[str] = []
-                for [name, value] in doc_type["properties"].items():
-                    value_type = self.serialize_doc_type(
-                        value["type"]["name"], fqname, value["type"]
-                    )
-                    signature.append(
-                        f"\"{name}\": {value_type if value['required'] else self.make_optional(value_type)}"
-                    )
-                intermediate = f"{{{', '.join(signature)}}}"
-            return (
-                intermediate
-                if type_name == "Object"
-                else self.make_optional(intermediate)
-            )
-
-        if type_name == "function":
+        if type_name == "Object":
+            return "Dict"
+        if type_name == "Function":
             return "Callable"
-
-        match = re.match(r"^Object<([^,]+),\s*([^)]+)>$", type_name)
-        if match:
-            return f"Dict[{self.serialize_doc_type(match.group(1), fqname)}, {self.serialize_doc_type(match.group(2), fqname)}]"
-
-        match = re.match(r"^Map<([^,]+),\s*([^)]+)>$", type_name)
-        if match:
-            return f"Dict[{self.serialize_doc_type(match.group(1), fqname)}, {self.serialize_doc_type(match.group(2), fqname)}]"
-
-        if re.match(enum_regex, type_name):
-            result = f"Literal[{', '.join(type_name.split('|'))}]"
-            return result.replace('"', "'")
-
-        match = re.match(r"^Array<(.*)>$", type_name)
-        if match:
-            return f"List[{self.serialize_doc_type(match.group(1), fqname)}]"
-
-        match = re.match(r"^\?(.*)$", type_name)
-        if match:
-            return self.make_optional(self.serialize_doc_type(match.group(1), fqname))
-
-        match = re.match(r"^null\|(.*)$", type_name)
-        if match:
-            return self.make_optional(self.serialize_doc_type(match.group(1), fqname))
-
-        # Union detection is greedy
-        if re.match(union_regex, type_name):
-            result = ", ".join(
-                list(
-                    map(
-                        lambda a: self.serialize_doc_type(a, fqname),
-                        type_name.split("|"),
-                    )
-                )
-            )
-            body = result.replace('"', "'")
-            return f"Union[{body}]"
-
-        return type_name
-
-    def rewrite_param_name(self, fqname: str, method_name: str, name: str) -> str:
-        if name == "expression":
-            return "pageFunction"
-        if method_name == "exposeBinding" and name == "binding":
-            return "playwrightBinding"
-        if method_name == "exposeFunction" and name == "binding":
-            return "playwrightFunction"
-        if method_name == "addInitScript" and name == "source":
-            return "script"
-        if fqname == "Selectors.register" and name == "source":
-            return "script"
-        if fqname == "Page.waitForRequest" and name == "url":
-            return "urlOrPredicate"
-        if fqname == "Page.waitForResponse" and name == "url":
-            return "urlOrPredicate"
-        return name
+        if type_name == "Buffer" or type_name == "ReadStream":
+            return "bytes"
+        if type_name == "Date":
+            return "datetime.datetime"
+        if type_name == "URL":
+            return "str"
+        if type_name == "RegExp":
+            return "Pattern[str]"
+        if type_name == "null" or type_name == "void":
+            return "None"
+        if type_name == "EvaluationArgument":
+            return "Dict"
+        if type_name in self.class_aliases:
+            return self.class_aliases[type_name]
+        return type["name"]
 
     def print_remainder(self) -> None:
-        for [class_name, value] in self.api.items():
-            class_name = re.sub(r"Chromium(.*)", r"\1", class_name)
-            class_name = re.sub(r"WebKit(.*)", r"\1", class_name)
-            class_name = re.sub(r"Firefox(.*)", r"\1", class_name)
-            for [method_name, method] in list(value["methods"].items()) + list(
-                value["properties"].items()
-            ):
-                entry = f"{class_name}.{method_name}"
+        for [class_name, clazz] in self.classes.items():
+            for [member_name, member] in clazz["members"].items():
+                if member.get("deprecated"):
+                    continue
+                if class_name in ["Error", "FormData"]:
+                    continue
+                entry = f"{class_name}.{member_name}"
                 if entry not in self.printed_entries:
                     self.errors.add(f"Method not implemented: {entry}")
 
@@ -494,8 +616,28 @@ def print_remainder(self) -> None:
             exit(1)
 
 
-if __name__ == "__main__":
-    DocumentationProvider().print_entry("Page", "goto")
-    DocumentationProvider().print_entry("Page", "evaluateHandle")
-    DocumentationProvider().print_entry("ElementHandle", "click")
-    DocumentationProvider().print_entry("Page", "screenshot")
+def works_for_python(item: Any) -> bool:
+    return not item["langs"].get("only") or "python" in item["langs"]["only"]
+
+
+def name_or_alias(item: Any) -> str:
+    alias = (
+        item["langs"].get("aliases").get("python")
+        if item["langs"].get("aliases")
+        else None
+    )
+    return alias or item["name"]
+
+
+def self_or_override(item: Any) -> Any:
+    override = (
+        item["langs"].get("overrides").get("python")
+        if item["langs"].get("overrides")
+        else None
+    )
+    return override or item
+
+
+def apply_type_or_override(member: Any) -> Any:
+    if member["langs"].get("types") and member["langs"]["types"].get("python"):
+        member["type"] = member["langs"]["types"]["python"]
diff --git a/scripts/example_async.py b/scripts/example_async.py
new file mode 100644
index 000000000..9fe5b6b11
--- /dev/null
+++ b/scripts/example_async.py
@@ -0,0 +1,30 @@
+# 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 asyncio
+
+from playwright.async_api import async_playwright
+
+
+async def main() -> None:
+    async with async_playwright() as p:
+        for browser_type in [p.chromium, p.firefox, p.webkit]:
+            browser = await browser_type.launch()
+            page = await browser.new_page()
+            assert await page.evaluate("() => 11 * 11") == 121
+            await browser.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/scripts/example_sync.py b/scripts/example_sync.py
new file mode 100644
index 000000000..0c65a5f07
--- /dev/null
+++ b/scripts/example_sync.py
@@ -0,0 +1,28 @@
+# 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.
+
+from playwright.sync_api import sync_playwright
+
+
+def main() -> None:
+    with sync_playwright() as p:
+        for browser_type in [p.chromium, p.firefox, p.webkit]:
+            browser = browser_type.launch()
+            page = browser.new_page()
+            assert page.evaluate("() => 11 * 11") == 121
+            browser.close()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/expected_api_mismatch.txt b/scripts/expected_api_mismatch.txt
index 9421100f4..d9bcc41a0 100644
--- a/scripts/expected_api_mismatch.txt
+++ b/scripts/expected_api_mismatch.txt
@@ -1,185 +1,26 @@
-# Missing methods
-Method not implemented: Browser.newBrowserCDPSession
-Method not implemented: Browser.startTracing
-Method not implemented: Browser.stopTracing
-Method not implemented: BrowserContext.backgroundPages
-Method not implemented: BrowserContext.newCDPSession
-Method not implemented: BrowserContext.serviceWorkers
-Method not implemented: BrowserContext.setHTTPCredentials
-Method not implemented: BrowserServer.close
-Method not implemented: BrowserServer.kill
-Method not implemented: BrowserServer.process
-Method not implemented: BrowserServer.wsEndpoint
-Method not implemented: BrowserType.launchServer
-Method not implemented: Coverage.startCSSCoverage
-Method not implemented: Coverage.startJSCoverage
-Method not implemented: Coverage.stopCSSCoverage
-Method not implemented: Coverage.stopJSCoverage
-Method not implemented: Download.createReadStream
-Method not implemented: Logger.isEnabled
-Method not implemented: Logger.log
-Method not implemented: Page.coverage
+# Playwright Python API
 
-# Parameter overloads
-Parameter not documented: BrowserContext.waitForEvent(predicate=)
-Parameter not documented: BrowserContext.waitForEvent(timeout=)
-Parameter not documented: Page.waitForEvent(predicate=)
-Parameter not documented: Page.waitForEvent(timeout=)
-Parameter not documented: Page.waitForRequest(predicate=)
-Parameter not documented: Page.waitForResponse(predicate=)
-Parameter not documented: Selectors.register(path=)
-Parameter not documented: WebSocket.waitForEvent(timeout=)
-Parameter not documented: WebSocket.waitForEvent(predicate=)
+# Hidden property
+Parameter not documented: Browser.new_context(default_browser_type=)
+Parameter not documented: Browser.new_page(default_browser_type=)
 
-# Viewport size
-Parameter type mismatch in Browser.newPage(viewport=): documented as Optional[Dict], code has Union[typing.Tuple[int, int], '0', NoneType]
-Parameter type mismatch in Browser.newContext(viewport=): documented as Optional[Dict], code has Union[typing.Tuple[int, int], '0', NoneType]
-Parameter type mismatch in BrowserType.launchPersistentContext(viewport=): documented as Optional[Dict], code has Union[typing.Tuple[int, int], '0', NoneType]
-Parameter type mismatch in Page.viewportSize(return=): documented as Optional[Dict], code has Optional[typing.Tuple[int, int]]
+# python-specific adapter for context manager support
+Method not documented: Disposable.close
 
-# Documented as Dict / Any
-Parameter type mismatch in BrowserContext.waitForEvent(return=): documented as Dict, code has Any
-Parameter type mismatch in ElementHandle.boundingBox(return=): documented as Optional[Dict], code has Optional[{"x": float, "y": float, "width": float, "height": float}]
-Parameter type mismatch in Page.waitForEvent(return=): documented as Dict, code has Any
-Parameter type mismatch in Request.failure(return=): documented as Optional[Dict], code has Optional[str]
-Parameter type mismatch in Response.json(return=): documented as Any, code has Union[Dict, List]
-Parameter type mismatch in WebSocket.waitForEvent(return=): documented as Dict, code has Any
+# One vs two arguments in the callback, Python explicitly unions.
+Parameter type mismatch in BrowserContext.route(handler=): documented as Callable[[Route, Request], Union[Any, Any]], code has Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
+Parameter type mismatch in BrowserContext.unroute(handler=): documented as Union[Callable[[Route, Request], Union[Any, Any]], None], code has Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
+Parameter type mismatch in Page.route(handler=): documented as Callable[[Route, Request], Union[Any, Any]], code has Union[Callable[[Route, Request], Any], Callable[[Route], Any]]
+Parameter type mismatch in Page.unroute(handler=): documented as Union[Callable[[Route, Request], Union[Any, Any]], None], code has Union[Callable[[Route, Request], Any], Callable[[Route], Any], None]
 
-# Geolocation
-Method not documented: BrowserContext.resetGeolocation
+# One vs two arguments in the callback, Python explicitly unions.
+Parameter type mismatch in Page.add_locator_handler(handler=): documented as Callable[[Locator], Any], code has Union[Callable[[Locator], Any], Callable[[], Any]]
 
-# Pathlib
-Parameter type mismatch in BrowserType.launch(executablePath=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in BrowserType.launch(downloadsPath=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in BrowserType.launchPersistentContext(downloadsPath=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in BrowserType.launchPersistentContext(executablePath=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in BrowserType.launchPersistentContext(userDataDir=): documented as str, code has Union[str, pathlib.Path]
-Parameter type mismatch in Download.saveAs(path=): documented as str, code has Union[str, pathlib.Path]
-Parameter type mismatch in ElementHandle.screenshot(path=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in Frame.addScriptTag(path=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in Frame.addStyleTag(path=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in Page.addScriptTag(path=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in Page.addStyleTag(path=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in Page.screenshot(path=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in Page.pdf(path=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
+Parameter type mismatch in BrowserContext.route_web_socket(handler=): documented as Callable[[WebSocketRoute], Union[Any, Any]], code has Callable[[WebSocketRoute], Any]
+Parameter type mismatch in Page.route_web_socket(handler=): documented as Callable[[WebSocketRoute], Union[Any, Any]], code has Callable[[WebSocketRoute], Any]
+Parameter type mismatch in WebSocketRoute.on_close(handler=): documented as Callable[[Union[int, undefined]], Union[Any, Any]], code has Callable[[Union[int, None], Union[str, None]], Any]
+Parameter type mismatch in WebSocketRoute.on_message(handler=): documented as Callable[[str], Union[Any, Any]], code has Callable[[Union[bytes, str]], Any]
 
-# Pattern
-Parameter type mismatch in BrowserContext.route(url=): documented as Union[str, RegExp, function(URL):boolean], code has Union[str, Pattern, Callable[[str], bool]]
-Parameter type mismatch in BrowserContext.unroute(url=): documented as Union[str, RegExp, function(URL):boolean], code has Union[str, Pattern, Callable[[str], bool]]
-Parameter type mismatch in Frame.waitForNavigation(url=): documented as Union[str, RegExp, Function, NoneType], code has Union[str, Pattern, Callable[[str], bool], NoneType]
-Parameter type mismatch in Page.frame(url=): documented as Union[str, RegExp, Function, NoneType], code has Union[str, Pattern, Callable[[str], bool], NoneType]
-Parameter type mismatch in Page.route(url=): documented as Union[str, RegExp, function(URL):boolean], code has Union[str, Pattern, Callable[[str], bool]]
-Parameter type mismatch in Page.unroute(url=): documented as Union[str, RegExp, function(URL):boolean], code has Union[str, Pattern, Callable[[str], bool]]
-Parameter type mismatch in Page.waitForNavigation(url=): documented as Union[str, RegExp, Function, NoneType], code has Union[str, Pattern, Callable[[str], bool], NoneType]
-Parameter type mismatch in Page.waitForRequest(urlOrPredicate=): documented as Union[str, RegExp, Function], code has Union[str, Pattern, Callable[[str], bool], NoneType]
-Parameter type mismatch in Page.waitForResponse(urlOrPredicate=): documented as Union[str, RegExp, function(Response):boolean], code has Union[str, Pattern, Callable[[str], bool], NoneType]
-
-# Add init script
-Parameter type mismatch in Page.addInitScript(script=): documented as Union[Callable, str, Dict], code has Optional[str]
-Parameter type mismatch in BrowserContext.addInitScript(script=): documented as Union[Callable, str, Dict], code has Optional[str]
-Parameter not documented: BrowserContext.addInitScript(path=)
-Parameter not documented: Page.addInitScript(path=)
-
-# File payload
-Parameter type mismatch in ElementHandle.setInputFiles(files=): documented as Union[str, List[str], Dict, List[Dict]], code has Union[str, pathlib.Path, Dict, List[str], List[pathlib.Path], List[Dict]]
-Parameter type mismatch in Page.setInputFiles(files=): documented as Union[str, List[str], Dict, List[Dict]], code has Union[str, Dict, List[str], List[Dict]]
-Parameter type mismatch in FileChooser.setFiles(files=): documented as Union[str, List[str], Dict, List[Dict]], code has Union[str, Dict, List[str], List[Dict]]
-Parameter type mismatch in Frame.setInputFiles(files=): documented as Union[str, List[str], Dict, List[Dict]], code has Union[str, pathlib.Path, Dict, List[str], List[pathlib.Path], List[Dict]]
-
-# Select option
-Parameter not implemented: ElementHandle.selectOption(values=)
-Parameter not documented: ElementHandle.selectOption(element=)
-Parameter not documented: Page.selectOption(element=)
-Parameter not documented: Page.selectOption(value=)
-Parameter not documented: Frame.selectOption(label=)
-Parameter not implemented: Page.selectOption(values=)
-Parameter not documented: ElementHandle.selectOption(label=)
-Parameter not documented: Frame.selectOption(index=)
-Parameter not documented: Page.selectOption(label=)
-Parameter not documented: Page.selectOption(index=)
-Parameter not documented: Frame.selectOption(element=)
-Parameter not documented: Frame.selectOption(value=)
-Parameter not documented: ElementHandle.selectOption(value=)
-Parameter not implemented: Frame.selectOption(values=)
-Parameter not documented: ElementHandle.selectOption(index=)
-
-# Evaluation argument
-Parameter type mismatch in ElementHandle.dispatchEvent(eventInit=): documented as Optional[EvaluationArgument], code has Optional[Dict]
-Parameter type mismatch in Frame.dispatchEvent(eventInit=): documented as Optional[EvaluationArgument], code has Optional[Dict]
-Parameter type mismatch in Page.dispatchEvent(eventInit=): documented as Optional[EvaluationArgument], code has Optional[Dict]
-
-# Route
-Parameter type mismatch in Page.unroute(handler=): documented as Optional[function(Route, Request)], code has Union[Callable[[Route], Any], Callable[[Route, Request], Any], NoneType]
-Parameter type mismatch in Page.route(handler=): documented as function(Route, Request), code has Union[Callable[[Route], Any], Callable[[Route, Request], Any]]
-Parameter type mismatch in BrowserContext.unroute(handler=): documented as Optional[function(Route, Request)], code has Union[Callable[[Route], Any], Callable[[Route, Request], Any], NoneType]
-Parameter type mismatch in BrowserContext.route(handler=): documented as function(Route, Request), code has Union[Callable[[Route], Any], Callable[[Route, Request], Any]]
-
-# Selectors
-Parameter type mismatch in Selectors.register(script=): documented as Union[Callable, str, Dict], code has Optional[str]
-
-# Device support
-Parameter not documented: Browser.newContext(defaultBrowserType=)
-Parameter not documented: Browser.newPage(defaultBrowserType=)
-
-# Logger
-Parameter not implemented: Browser.newContext(logger=)
-Parameter not implemented: BrowserType.launch(logger=)
-Parameter not implemented: BrowserType.launchPersistentContext(logger=)
-Parameter not implemented: Browser.newPage(logger=)
-
-# Deprecated
-Parameter not implemented: Page.addInitScript(arg=)
-Parameter not implemented: BrowserContext.addInitScript(arg=)
-Method not implemented: BrowserType.connect
-Parameter not implemented: Browser.newContext(videoSize=)
-Parameter not implemented: BrowserType.launchPersistentContext(videosPath=)
-Parameter not implemented: Browser.newPage(videosPath=)
-Parameter not implemented: Browser.newPage(videoSize=)
-Parameter not implemented: Browser.newContext(videosPath=)
-Parameter not implemented: BrowserType.launchPersistentContext(videoSize=)
-
-# OptionsOr
-Parameter not implemented: Page.waitForEvent(optionsOrPredicate=)
-Parameter not implemented: BrowserContext.waitForEvent(optionsOrPredicate=)
-Parameter not implemented: WebSocket.waitForEvent(optionsOrPredicate=)
-
-# Cookies are documented as Array<Object> in md, so not parsed.
-Parameter type mismatch in Browser.newContext(storageState=): documented as Union[str, Dict, NoneType], code has Union[{"cookies": Optional[List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]], "origins": Optional[List[Dict]]}, str, pathlib.Path, NoneType]
-Parameter type mismatch in Browser.newPage(storageState=): documented as Union[str, Dict, NoneType], code has Union[{"cookies": Optional[List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]], "origins": Optional[List[Dict]]}, str, pathlib.Path, NoneType]
-Parameter type mismatch in BrowserContext.storageState(return=): documented as {"cookies": List[Dict], "origins": List[Dict]}, code has {"cookies": Optional[List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]], "origins": Optional[List[Dict]]}
-Parameter type mismatch in BrowserContext.addCookies(cookies=): documented as List[Dict], code has List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]
-Parameter type mismatch in BrowserContext.cookies(return=): documented as List[Dict], code has List[{"name": str, "value": str, "url": Optional[str], "domain": Optional[str], "path": Optional[str], "expires": Optional[int], "httpOnly": Optional[bool], "secure": Optional[bool], "sameSite": Optional[Literal['Strict', 'Lax', 'None']]}]
-Parameter type mismatch in Response.finished(return=): documented as Optional[Error], code has Optional[str]
-
-# Path
-Parameter type mismatch in BrowserContext.storageState(path=): documented as Optional[str], code has Union[str, pathlib.Path, NoneType]
-
-# FloatPoint
-Parameter type mismatch in Frame.click(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-Parameter type mismatch in ElementHandle.hover(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-Parameter type mismatch in Frame.tap(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-Parameter type mismatch in ElementHandle.click(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-Parameter type mismatch in Frame.hover(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-Parameter type mismatch in ElementHandle.tap(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-Parameter type mismatch in Page.click(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-Parameter type mismatch in Page.tap(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-Parameter type mismatch in Page.dblclick(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-Parameter type mismatch in ElementHandle.dblclick(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-Parameter type mismatch in Frame.dblclick(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-Parameter type mismatch in Page.hover(position=): documented as Optional[{"x": float, "y": float}], code has Optional[typing.Tuple[float, float]]
-
-# Credentials
-Parameter type mismatch in Browser.newPage(httpCredentials=): documented as Optional[{"username": str, "password": str}], code has Optional[typing.Tuple[str, str]]
-Parameter type mismatch in BrowserType.launchPersistentContext(httpCredentials=): documented as Optional[{"username": str, "password": str}], code has Optional[typing.Tuple[str, str]]
-Parameter type mismatch in Browser.newContext(httpCredentials=): documented as Optional[{"username": str, "password": str}], code has Optional[typing.Tuple[str, str]]
-
-# HAR & Video
-Parameter type mismatch in Browser.newContext(recordHarPath=): documented as str, code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in BrowserType.launchPersistentContext(recordVideoDir=): documented as str, code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in Browser.newPage(recordVideoSize=): documented as Optional[{"width": int, "height": int}], code has Optional[typing.Tuple[int, int]]
-Parameter type mismatch in BrowserType.launchPersistentContext(recordHarPath=): documented as str, code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in Browser.newPage(recordVideoDir=): documented as str, code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in Browser.newContext(recordVideoSize=): documented as Optional[{"width": int, "height": int}], code has Optional[typing.Tuple[int, int]]
-Parameter type mismatch in Browser.newContext(recordVideoDir=): documented as str, code has Union[str, pathlib.Path, NoneType]
-Parameter type mismatch in BrowserType.launchPersistentContext(recordVideoSize=): documented as Optional[{"width": int, "height": int}], code has Optional[typing.Tuple[int, int]]
-Parameter type mismatch in Browser.newPage(recordHarPath=): documented as str, code has Union[str, pathlib.Path, NoneType]
+# Async API additionally accepts an `async def` predicate.
+Parameter type mismatch in Page.expect_request(url_or_predicate=): documented as Union[Callable[[Request], bool], Pattern[str], str], code has Union[Callable[[Request], Union[bool, typing.Awaitable[bool]]], Pattern[str], str]
+Parameter type mismatch in Page.expect_response(url_or_predicate=): documented as Union[Callable[[Response], bool], Pattern[str], str], code has Union[Callable[[Response], Union[bool, typing.Awaitable[bool]]], Pattern[str], str]
diff --git a/scripts/generate_api.py b/scripts/generate_api.py
index a5b2a2e8f..e45f629cb 100644
--- a/scripts/generate_api.py
+++ b/scripts/generate_api.py
@@ -13,65 +13,141 @@
 # limitations under the License.
 
 import re
+import sys
 from types import FunctionType
-from typing import (  # type: ignore
-    Any,
-    List,
-    Match,
-    Union,
-    cast,
-    get_args,
-    get_origin,
-    get_type_hints,
-)
+from typing import Any, Dict, List, Match, Optional, Union, cast, get_args, get_origin
+from typing import get_type_hints as typing_get_type_hints
 
-from playwright._impl._accessibility import Accessibility
+from playwright._impl._assertions import (
+    APIResponseAssertions,
+    LocatorAssertions,
+    PageAssertions,
+)
 from playwright._impl._browser import Browser
 from playwright._impl._browser_context import BrowserContext
 from playwright._impl._browser_type import BrowserType
 from playwright._impl._cdp_session import CDPSession
-from playwright._impl._chromium_browser_context import ChromiumBrowserContext
+from playwright._impl._clock import Clock
 from playwright._impl._console_message import ConsoleMessage
+from playwright._impl._debugger import Debugger
 from playwright._impl._dialog import Dialog
+from playwright._impl._disposable import Disposable
 from playwright._impl._download import Download
 from playwright._impl._element_handle import ElementHandle
+from playwright._impl._fetch import APIRequest, APIRequestContext, APIResponse
 from playwright._impl._file_chooser import FileChooser
 from playwright._impl._frame import Frame
-from playwright._impl._helper import to_snake_case
+from playwright._impl._helper import Error, to_snake_case
 from playwright._impl._input import Keyboard, Mouse, Touchscreen
 from playwright._impl._js_handle import JSHandle, Serializable
-from playwright._impl._network import Request, Response, Route, WebSocket
-from playwright._impl._page import BindingCall, Page, Worker
+from playwright._impl._locator import FrameLocator, Locator
+from playwright._impl._network import (
+    Request,
+    Response,
+    Route,
+    WebSocket,
+    WebSocketRoute,
+)
+from playwright._impl._page import Page, Worker
 from playwright._impl._playwright import Playwright
+from playwright._impl._screencast import Screencast
 from playwright._impl._selectors import Selectors
+from playwright._impl._tracing import Tracing
 from playwright._impl._video import Video
+from playwright._impl._web_error import WebError
+
+SYNC_API = False
 
 
 def process_type(value: Any, param: bool = False) -> str:
     value = str(value)
+    value = re.sub("pathlib._local.Path", "pathlib.Path", value)
     value = re.sub(r"<class '([^']+)'>", r"\1", value)
+    value = re.sub(r"NoneType", "None", value)
+    value = re.sub(r"playwright\._impl\._api_structures.([\w]+)", r"\1", value)
     value = re.sub(r"playwright\._impl\.[\w]+\.([\w]+)", r'"\1"', value)
     value = re.sub(r"typing.Literal", "Literal", value)
+    if SYNC_API:
+        # Sync API does not accept awaitable callbacks; collapse
+        # Union[X, Awaitable[X]] (used for predicates the async API also
+        # accepts as `async def`) down to just X.
+        value = re.sub(
+            r"typing\.Union\[([^\[\],]+),\s*typing\.Awaitable\[\1\]\]",
+            r"\1",
+            value,
+        )
     if param:
-        value = re.sub(r"^typing.Union\[([^,]+), NoneType\]$", r"\1 = None", value)
+        value = re.sub(r"^typing.Union\[([^,]+), None\]$", r"\1 = None", value)
+        value = re.sub(
+            r"typing.Union\[(Literal\[[^\]]+\]), None\]", r"\1 = None", value
+        )
         value = re.sub(
-            r"typing.Union\[(Literal\[[^\]]+\]), NoneType\]", r"\1 = None", value
+            r"^typing.Union\[(.+), None\]$", r"typing.Union[\1] = None", value
         )
         value = re.sub(
-            r"^typing.Union\[(.+), NoneType\]$", r"typing.Union[\1] = None", value
+            r"^typing.Optional\[(.+)\]$", r"typing.Optional[\1] = None", value
         )
+        if not re.match(r"typing.Optional\[.*\] = None", value):
+            value = re.sub(r"(.*) = None", r"typing.Optional[\1] = None", value)
     return value
 
 
+positional_exceptions = [
+    r"abort\.errorCode",
+    r"accept\.promptText",
+    r"add_init_script\.script",
+    r"cookies\.urls",
+    r"dispatch_event\.eventInit",
+    r"eval.*\.arg",
+    r"expect_.*\.predicate",
+    r"evaluate_handle\.arg",
+    r"frame.*\.name",
+    r"register\.script",
+    r"select_option\.value",
+    r"send\.params",
+    r"set_geolocation\.geolocation",
+    r"wait_for_.*\.predicate",
+    r"wait_for_load_state\.state",
+    r"unroute\.handler",
+]
+
+
+def is_positional_exception(key: str) -> bool:
+    for pattern in positional_exceptions:
+        if re.match(pattern, key):
+            return True
+    return False
+
+
 def signature(func: FunctionType, indent: int) -> str:
     hints = get_type_hints(func, globals())
     tokens = ["self"]
     split = ",\n" + " " * indent
 
+    saw_optional = False
     for [name, value] in hints.items():
         if name == "return":
             continue
+        positional_exception = is_positional_exception(f"{func.__name__}.{name}")
+        if saw_optional and positional_exception:
+            raise Exception(
+                "Positional exception is not first in the list "
+                + f"{func.__name__}.{name}"
+            )
         processed = process_type(value, True)
+        if name == "timeout":
+            processed = re.sub(
+                r"\bfloat\b",
+                "typing.Union[float, datetime.timedelta]",
+                processed,
+            )
+        if (
+            not positional_exception
+            and not saw_optional
+            and processed.startswith("typing.Optional")
+        ):
+            saw_optional = True
+            tokens.append("*")
         tokens.append(f"{to_snake_case(name)}: {processed}")
     return split.join(tokens)
 
@@ -84,16 +160,32 @@ def arguments(func: FunctionType, indent: int) -> str:
         value_str = str(value)
         if name == "return":
             continue
+        assert (
+            "_" not in name
+        ), f"Underscore in impl classes is not allowed, use camel case, func={func}, name={name}"
         if "Callable" in value_str:
             tokens.append(f"{name}=self._wrap_handler({to_snake_case(name)})")
+        elif name == "timeout" and "float" in value_str:
+            tokens.append(f"{name}=to_milliseconds({to_snake_case(name)})")
         elif (
             "typing.Any" in value_str
             or "typing.Dict" in value_str
+            or "typing.Sequence" in value_str
             or "Handle" in value_str
         ):
             tokens.append(f"{name}=mapping.to_impl({to_snake_case(name)})")
-        elif re.match(r"<class 'playwright\._impl\.[\w]+\.[\w]+", value_str):
+        elif (
+            re.match(r"<class 'playwright\._impl\.[\w]+\.[\w]+", value_str)
+            and "_api_structures" not in value_str
+        ):
             tokens.append(f"{name}={to_snake_case(name)}._impl_obj")
+        elif (
+            re.match(r"typing\.Optional\[playwright\._impl\.[\w]+\.[\w]+\]", value_str)
+            and "_api_structures" not in value_str
+        ):
+            tokens.append(
+                f"{name}={to_snake_case(name)}._impl_obj if {to_snake_case(name)} else None"
+            )
         else:
             tokens.append(f"{name}={to_snake_case(name)}")
     return split.join(tokens)
@@ -121,7 +213,10 @@ def return_value(value: Any) -> List[str]:
         and str(get_args(value)[1]) == "<class 'NoneType'>"
     ):
         return ["mapping.from_impl_nullable(", ")"]
-    if str(get_origin(value)) == "<class 'list'>":
+    if str(get_origin(value)) in [
+        "<class 'list'>",
+        "<class 'collections.abc.Sequence'>",
+    ]:
         return ["mapping.from_impl_list(", ")"]
     if str(get_origin(value)) == "<class 'dict'>":
         return ["mapping.from_impl_dict(", ")"]
@@ -145,77 +240,121 @@ def return_value(value: Any) -> List[str]:
 
 
 import typing
-import sys
 import pathlib
+import datetime
 
-if sys.version_info >= (3, 8):  # pragma: no cover
-    from typing import Literal
-else:  # pragma: no cover
-    from typing_extensions import Literal
-
-
-from playwright._impl._accessibility import Accessibility as AccessibilityImpl
-from playwright._impl._api_types import (
-    DeviceDescriptor,
-    FilePayload,
-    FloatRect,
-    Geolocation,
-    PdfMargins,
-    ProxySettings,
-    SourceLocation,
-)
+from typing import Literal
+
+
+from playwright._impl._api_structures import Cookie, SetCookieParam, FloatRect, FilePayload, Geolocation, HttpCredentials, PdfMargins, Position, ProxySettings, ResourceTiming, SourceLocation, StorageState, ClientCertificate, ViewportSize, RemoteAddr, SecurityDetails, RequestSizes, NameValue, TracingGroupLocation, DebuggerLocation, DebuggerPausedDetails, ScreencastFrame, BrowserBindResult, WebErrorLocation, DropPayload
 from playwright._impl._browser import Browser as BrowserImpl
 from playwright._impl._browser_context import BrowserContext as BrowserContextImpl
 from playwright._impl._browser_type import BrowserType as BrowserTypeImpl
+from playwright._impl._clock import Clock as ClockImpl
 from playwright._impl._cdp_session import CDPSession as CDPSessionImpl
-from playwright._impl._chromium_browser_context import ChromiumBrowserContext as ChromiumBrowserContextImpl
 from playwright._impl._console_message import ConsoleMessage as ConsoleMessageImpl
+from playwright._impl._debugger import Debugger as DebuggerImpl
 from playwright._impl._dialog import Dialog as DialogImpl
+from playwright._impl._disposable import Disposable as DisposableImpl
 from playwright._impl._download import Download as DownloadImpl
 from playwright._impl._element_handle import ElementHandle as ElementHandleImpl
 from playwright._impl._file_chooser import FileChooser as FileChooserImpl
 from playwright._impl._frame import Frame as FrameImpl
-from playwright._impl._api_structures import Cookie, ResourceTiming, StorageState
 from playwright._impl._input import Keyboard as KeyboardImpl, Mouse as MouseImpl, Touchscreen as TouchscreenImpl
 from playwright._impl._js_handle import JSHandle as JSHandleImpl
-from playwright._impl._network import Request as RequestImpl, Response as ResponseImpl, Route as RouteImpl, WebSocket as WebSocketImpl
-from playwright._impl._page import BindingCall as BindingCallImpl, Page as PageImpl, Worker as WorkerImpl
+from playwright._impl._network import Request as RequestImpl, Response as ResponseImpl, Route as RouteImpl, WebSocket as WebSocketImpl, WebSocketRoute as WebSocketRouteImpl
+from playwright._impl._page import Page as PageImpl, Worker as WorkerImpl
+from playwright._impl._web_error import WebError as WebErrorImpl
 from playwright._impl._playwright import Playwright as PlaywrightImpl
 from playwright._impl._selectors import Selectors as SelectorsImpl
+from playwright._impl._screencast import Screencast as ScreencastImpl
 from playwright._impl._video import Video as VideoImpl
-from playwright._impl._logger import log_api
-
+from playwright._impl._tracing import Tracing as TracingImpl
+from playwright._impl._locator import Locator as LocatorImpl, FrameLocator as FrameLocatorImpl
+from playwright._impl._errors import Error
+from playwright._impl._form_data import FormData
+from playwright._impl._helper import to_milliseconds
+from playwright._impl._fetch import APIRequest as APIRequestImpl, APIResponse as APIResponseImpl, APIRequestContext as APIRequestContextImpl
+from playwright._impl._assertions import PageAssertions as PageAssertionsImpl, LocatorAssertions as LocatorAssertionsImpl, APIResponseAssertions as APIResponseAssertionsImpl
 """
 
 
-all_types = [
+generated_types = [
     Request,
     Response,
     Route,
     WebSocket,
+    WebSocketRoute,
     Keyboard,
     Mouse,
     Touchscreen,
     JSHandle,
     ElementHandle,
-    Accessibility,
     FileChooser,
     Frame,
+    FrameLocator,
     Worker,
     Selectors,
+    Clock,
     ConsoleMessage,
+    Debugger,
     Dialog,
     Download,
+    Screencast,
     Video,
-    BindingCall,
     Page,
+    WebError,
     BrowserContext,
     CDPSession,
-    ChromiumBrowserContext,
     Browser,
     BrowserType,
     Playwright,
+    Tracing,
+    Locator,
+    APIResponse,
+    APIRequestContext,
+    APIRequest,
+    PageAssertions,
+    LocatorAssertions,
+    APIResponseAssertions,
+    Disposable,
+]
+
+all_types = generated_types + [
+    Error,
 ]
 
 api_globals = globals()
 assert Serializable
+
+
+# Python 3.11+ does not treat default args with None as Optional anymore, this wrapper will still wrap them.
+# https://github.com/python/cpython/issues/90353
+def get_type_hints(func: Any, globalns: Any) -> Dict[str, Any]:
+    original_value = typing_get_type_hints(func, globalns)
+    if sys.version_info < (3, 11):
+        return original_value
+    for key, value in _get_defaults(func).items():
+        if value is None and original_value[key] is not Optional:
+            original_value[key] = Optional[original_value[key]]
+    return original_value
+
+
+def _get_defaults(func: Any) -> Dict[str, Any]:
+    """Internal helper to extract the default arguments, by name."""
+    try:
+        code = func.__code__
+    except AttributeError:
+        # Some built-in functions don't have __code__, __defaults__, etc.
+        return {}
+    pos_count = code.co_argcount
+    arg_names = code.co_varnames
+    arg_names = arg_names[:pos_count]
+    defaults = func.__defaults__ or ()
+    kwdefaults = func.__kwdefaults__
+    res = dict(kwdefaults) if kwdefaults else {}
+    pos_offset = pos_count - len(defaults)
+    for name, value in zip(arg_names[pos_offset:], defaults):
+        assert name not in res
+        res[name] = value
+    return res
diff --git a/scripts/generate_async_api.py b/scripts/generate_async_api.py
index db8c63f51..e844bc400 100755
--- a/scripts/generate_async_api.py
+++ b/scripts/generate_async_api.py
@@ -16,14 +16,14 @@
 import inspect
 import re
 from types import FunctionType
-from typing import Any, get_type_hints  # type: ignore
+from typing import Any
 
-from playwright._impl._helper import to_snake_case
-from scripts.documentation_provider import DocumentationProvider
-from scripts.generate_api import (
-    all_types,
+from documentation_provider import DocumentationProvider
+from generate_api import (
     api_globals,
     arguments,
+    generated_types,
+    get_type_hints,
     header,
     process_type,
     return_type,
@@ -32,42 +32,42 @@
     signature,
 )
 
-documentation_provider = DocumentationProvider()
+documentation_provider = DocumentationProvider(True)
 
 
 def generate(t: Any) -> None:
     print("")
     class_name = short_name(t)
     base_class = t.__bases__[0].__name__
-    base_sync_class = (
-        "AsyncBase"
-        if base_class == "ChannelOwner" or base_class == "object"
-        else base_class
-    )
+    if class_name in ["Page", "BrowserContext", "Browser", "Disposable"]:
+        base_sync_class = "AsyncContextManager"
+    elif base_class in ["ChannelOwner", "object", "AssertionsBase"]:
+        base_sync_class = "AsyncBase"
+    else:
+        base_sync_class = base_class
     print(f"class {class_name}({base_sync_class}):")
     print("")
-    print(f"    def __init__(self, obj: {class_name}Impl):")
-    print("        super().__init__(obj)")
+    documentation_provider.print_events(class_name)
     for [name, type] in get_type_hints(t, api_globals).items():
         print("")
         print("    @property")
-        print(f"    def {to_snake_case(name)}(self) -> {process_type(type)}:")
-        documentation_provider.print_entry(class_name, name, {"return": type})
+        print(f"    def {name}(self) -> {process_type(type)}:")
+        documentation_provider.print_entry(class_name, name, {"return": type}, True)
         [prefix, suffix] = return_value(type)
         prefix = "        return " + prefix + f"self._impl_obj.{name}"
         print(f"{prefix}{suffix}")
     for [name, value] in t.__dict__.items():
         if name.startswith("_"):
             continue
-        if not name.startswith("_") and str(value).startswith("<property"):
+        if str(value).startswith("<property"):
             value = value.fget
             print("")
             print("    @property")
             print(
-                f"    def {to_snake_case(name)}({signature(value, len(name) + 9)}) -> {return_type(value)}:"
+                f"    def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:"
             )
             documentation_provider.print_entry(
-                class_name, name, get_type_hints(value, api_globals)
+                class_name, name, get_type_hints(value, api_globals), True
             )
             [prefix, suffix] = return_value(
                 get_type_hints(value, api_globals)["return"]
@@ -75,85 +75,57 @@ def generate(t: Any) -> None:
             prefix = "        return " + prefix + f"self._impl_obj.{name}"
             print(f"{prefix}{arguments(value, len(prefix))}{suffix}")
     for [name, value] in t.__dict__.items():
-        if (
-            not name.startswith("_")
-            and isinstance(value, FunctionType)
-            and "expect_" not in name
-            and "remove_listener" != name
-        ):
+        if isinstance(value, FunctionType) and "remove_listener" != name:
+            # List of dunder methods to allow without docs
+            allow_without_docs_methods = [
+                "__getitem__",
+            ]
+            if name.startswith("_") and name not in allow_without_docs_methods:
+                continue
             is_async = inspect.iscoroutinefunction(value)
-            print("")
-            async_prefix = "async " if is_async else ""
-            await_prefix = "await " if is_async else ""
-            print(
-                f"    {async_prefix}def {to_snake_case(name)}({signature(value, len(name) + 9)}) -> {return_type(value)}:"
-            )
-            documentation_provider.print_entry(
-                class_name, name, get_type_hints(value, api_globals)
-            )
-            [prefix, suffix] = return_value(
-                get_type_hints(value, api_globals)["return"]
-            )
-            prefix = prefix + f"{await_prefix}self._impl_obj.{name}("
-            suffix = ")" + suffix
-            print(
-                f"""
-        try:
-            log_api("=> {to_snake_case(class_name)}.{to_snake_case(name)} started")
-            result = {prefix}{arguments(value, len(prefix))}{suffix}
-            log_api("<= {to_snake_case(class_name)}.{to_snake_case(name)} succeded")
-            return result
-        except Exception as e:
-            log_api("<= {to_snake_case(class_name)}.{to_snake_case(name)} failed")
-            raise e"""
-            )
-        if "expect_" in name:
-            print("")
             return_type_value = return_type(value)
             return_type_value = re.sub(r"\"([^\"]+)Impl\"", r"\1", return_type_value)
-            event_name = re.sub(r"expect_(.*)", r"\1", name)
-            event_name = re.sub(r"_", "", event_name)
-            event_name = re.sub(r"consolemessage", "console", event_name)
-
-            print(
-                f"""    def {to_snake_case(name)}({signature(value, len(name) + 9)}) -> Async{return_type_value}:
-        \"\"\"{class_name}.{name}
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
-
-        async with page.expect_{event_name}() as event_info:
-            await page.click("button")
-        value = event_info.value
-
-        Parameters
-        ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        \"\"\""""
+            return_type_value = return_type_value.replace(
+                "EventContextManager", "AsyncEventContextManager"
             )
-
-            wait_for_method = "waitForEvent(event, predicate, timeout)"
-            if event_name == "request":
-                wait_for_method = "waitForRequest(url, predicate, timeout)"
-            elif event_name == "response":
-                wait_for_method = "waitForResponse(url, predicate, timeout)"
-            elif event_name == "loadstate":
-                wait_for_method = "waitForLoadState(state, timeout)"
-            elif event_name == "navigation":
-                wait_for_method = "waitForNavigation(url, wait_until, timeout)"
-            elif event_name != "event":
-                print(f'        event = "{event_name}"')
-
+            return_type_value = return_type_value.replace(
+                '"Disposable"', '"AsyncContextManager"'
+            ).replace('"DisposableStub"', '"AsyncContextManager"')
+            print("")
+            if name in ("expect_event", "wait_for_event"):
+                documentation_provider.print_event_overloads(class_name, name)
+            async_prefix = "async " if is_async else ""
             print(
-                f"        return AsyncEventContextManager(self._impl_obj.{wait_for_method})"
+                f"    {async_prefix}def {name}({signature(value, len(name) + 9)}) -> {return_type_value}:"
             )
-
+            # Allow dunder methods without docs
+            if name not in allow_without_docs_methods:
+                documentation_provider.print_entry(
+                    class_name, name, get_type_hints(value, api_globals)
+                )
+            if class_name in [
+                "LocatorAssertions",
+                "PageAssertions",
+                "APIResponseAssertions",
+            ]:
+                print("        __tracebackhide__ = True")
+            if "expect_" in name:
+                print("")
+                print(
+                    f"        return AsyncEventContextManager(self._impl_obj.{name}({arguments(value, 12)}).future)"
+                )
+            else:
+                [prefix, suffix] = return_value(
+                    get_type_hints(value, api_globals)["return"]
+                )
+                if is_async:
+                    prefix += "await "
+                prefix = prefix + f"self._impl_obj.{name}("
+                suffix = ")" + suffix
+                print(
+                    f"""
+        return {prefix}{arguments(value, len(prefix))}{suffix}"""
+                )
     print("")
     print(f"mapping.register({class_name}Impl, {class_name})")
 
@@ -161,11 +133,10 @@ def generate(t: Any) -> None:
 def main() -> None:
     print(header)
     print(
-        "from playwright._impl._async_base import AsyncEventContextManager, AsyncBase, mapping"
+        "from playwright._impl._async_base import AsyncEventContextManager, AsyncBase, AsyncContextManager, mapping"
     )
-    print("NoneType = type(None)")
 
-    for t in all_types:
+    for t in generated_types:
         generate(t)
     documentation_provider.print_remainder()
 
diff --git a/scripts/generate_sync_api.py b/scripts/generate_sync_api.py
index 3385bfe6c..fa6ac8702 100755
--- a/scripts/generate_sync_api.py
+++ b/scripts/generate_sync_api.py
@@ -15,15 +15,17 @@
 
 import inspect
 import re
+import sys
 from types import FunctionType
-from typing import Any, get_type_hints  # type: ignore
+from typing import Any
 
-from playwright._impl._helper import to_snake_case
-from scripts.documentation_provider import DocumentationProvider
-from scripts.generate_api import (
-    all_types,
+import generate_api
+from documentation_provider import DocumentationProvider
+from generate_api import (
     api_globals,
     arguments,
+    generated_types,
+    get_type_hints,
     header,
     process_type,
     return_type,
@@ -32,42 +34,44 @@
     signature,
 )
 
-documentation_provider = DocumentationProvider()
+generate_api.SYNC_API = True
+
+documentation_provider = DocumentationProvider(False)
 
 
 def generate(t: Any) -> None:
     print("")
     class_name = short_name(t)
     base_class = t.__bases__[0].__name__
-    base_sync_class = (
-        "SyncBase"
-        if base_class == "ChannelOwner" or base_class == "object"
-        else base_class
-    )
+    if class_name in ["Page", "BrowserContext", "Browser", "Disposable"]:
+        base_sync_class = "SyncContextManager"
+    elif base_class in ["ChannelOwner", "object", "AssertionsBase"]:
+        base_sync_class = "SyncBase"
+    else:
+        base_sync_class = base_class
     print(f"class {class_name}({base_sync_class}):")
     print("")
-    print(f"    def __init__(self, obj: {class_name}Impl):")
-    print("        super().__init__(obj)")
+    documentation_provider.print_events(class_name)
     for [name, type] in get_type_hints(t, api_globals).items():
         print("")
         print("    @property")
-        print(f"    def {to_snake_case(name)}(self) -> {process_type(type)}:")
-        documentation_provider.print_entry(class_name, name, {"return": type})
+        print(f"    def {name}(self) -> {process_type(type)}:")
+        documentation_provider.print_entry(class_name, name, {"return": type}, True)
         [prefix, suffix] = return_value(type)
         prefix = "        return " + prefix + f"self._impl_obj.{name}"
         print(f"{prefix}{suffix}")
     for [name, value] in t.__dict__.items():
         if name.startswith("_"):
             continue
-        if not name.startswith("_") and str(value).startswith("<property"):
+        if str(value).startswith("<property"):
             value = value.fget
             print("")
             print("    @property")
             print(
-                f"    def {to_snake_case(name)}({signature(value, len(name) + 9)}) -> {return_type(value)}:"
+                f"    def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:"
             )
             documentation_provider.print_entry(
-                class_name, name, get_type_hints(value, api_globals)
+                class_name, name, get_type_hints(value, api_globals), True
             )
             [prefix, suffix] = return_value(
                 get_type_hints(value, api_globals)["return"]
@@ -75,102 +79,68 @@ def generate(t: Any) -> None:
             prefix = "        return " + prefix + f"self._impl_obj.{name}"
             print(f"{prefix}{arguments(value, len(prefix))}{suffix}")
     for [name, value] in t.__dict__.items():
-        if name in ["expect_dialog"]:
-            continue
-        if (
-            not name.startswith("_")
-            and isinstance(value, FunctionType)
-            and "expect_" not in name
-            and "remove_listener" != name
-        ):
+        if isinstance(value, FunctionType) and "remove_listener" != name:
+            # List of dunder methods to allow without docs
+            allow_without_docs_methods = [
+                "__getitem__",
+            ]
+            if name.startswith("_") and name not in allow_without_docs_methods:
+                continue
             is_async = inspect.iscoroutinefunction(value)
-            print("")
-            print(
-                f"    def {to_snake_case(name)}({signature(value, len(name) + 9)}) -> {return_type(value)}:"
-            )
-            documentation_provider.print_entry(
-                class_name, name, get_type_hints(value, api_globals)
-            )
-            [prefix, suffix] = return_value(
-                get_type_hints(value, api_globals)["return"]
-            )
-            if is_async:
-                prefix = prefix + f"self._sync(self._impl_obj.{name}("
-                suffix = "))" + suffix
-            else:
-                prefix = prefix + f"self._impl_obj.{name}("
-                suffix = ")" + suffix
-
-            print(
-                f"""
-        try:
-            log_api("=> {to_snake_case(class_name)}.{to_snake_case(name)} started")
-            result = {prefix}{arguments(value, len(prefix))}{suffix}
-            log_api("<= {to_snake_case(class_name)}.{to_snake_case(name)} succeded")
-            return result
-        except Exception as e:
-            log_api("<= {to_snake_case(class_name)}.{to_snake_case(name)} failed")
-            raise e"""
-            )
-        if "expect_" in name:
-            print("")
             return_type_value = return_type(value)
             return_type_value = re.sub(r"\"([^\"]+)Impl\"", r"\1", return_type_value)
-            event_name = re.sub(r"expect_(.*)", r"\1", name)
-            event_name = re.sub(r"_", "", event_name)
-            event_name = re.sub(r"consolemessage", "console", event_name)
-
-            print(
-                f"""    def {name}({signature(value, len(name) + 9)}) -> {return_type_value}:
-        \"\"\"{class_name}.{name}
-
-        Returns context manager that waits for ``event`` to fire upon exit. It passes event's value
-        into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw
-        an error if the page is closed before the ``event`` is fired.
-
-        with page.expect_{event_name}() as event_info:
-            page.click("button")
-        value = event_info.value
-
-        Parameters
-        ----------
-        predicate : Optional[typing.Callable[[Any], bool]]
-            Predicate receiving event data.
-        timeout : Optional[int]
-            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) or
-            page.setDefaultTimeout(timeout) methods.
-        \"\"\""""
-            )
-
-            wait_for_method = "waitForEvent(event, predicate, timeout)"
-            if event_name == "request":
-                wait_for_method = "waitForRequest(url, predicate, timeout)"
-            elif event_name == "response":
-                wait_for_method = "waitForResponse(url, predicate, timeout)"
-            elif event_name == "loadstate":
-                wait_for_method = "waitForLoadState(state, timeout)"
-            elif event_name == "navigation":
-                wait_for_method = "waitForNavigation(url, wait_until, timeout)"
-            elif event_name != "event":
-                print(f'        event = "{event_name}"')
-
+            return_type_value = return_type_value.replace(
+                '"Disposable"', '"SyncContextManager"'
+            ).replace('"DisposableStub"', '"SyncContextManager"')
+            print("")
+            if name in ("expect_event", "wait_for_event"):
+                documentation_provider.print_event_overloads(class_name, name)
             print(
-                f"        return EventContextManager(self, self._impl_obj.{wait_for_method})"
+                f"    def {name}({signature(value, len(name) + 9)}) -> {return_type_value}:"
             )
-
+            # Allow dunder methods without docs
+            if name not in allow_without_docs_methods:
+                documentation_provider.print_entry(
+                    class_name, name, get_type_hints(value, api_globals)
+                )
+            if class_name in [
+                "LocatorAssertions",
+                "PageAssertions",
+                "APIResponseAssertions",
+            ]:
+                print("        __tracebackhide__ = True")
+            if "expect_" in name:
+                print(
+                    f"        return EventContextManager(self, self._impl_obj.{name}({arguments(value, 12)}).future)"
+                )
+            else:
+                [prefix, suffix] = return_value(
+                    get_type_hints(value, api_globals)["return"]
+                )
+                if is_async:
+                    prefix += f"self._sync(self._impl_obj.{name}("
+                    suffix = "))" + suffix
+                else:
+                    prefix += f"self._impl_obj.{name}("
+                    suffix = ")" + suffix
+
+                print(
+                    f"""
+        return {prefix}{arguments(value, len(prefix))}{suffix}"""
+                )
     print("")
     print(f"mapping.register({class_name}Impl, {class_name})")
 
 
 def main() -> None:
+    assert sys.version_info >= (3, 9)
+
     print(header)
     print(
-        "from playwright._impl._sync_base import EventContextManager, SyncBase, mapping"
+        "from playwright._impl._sync_base import EventContextManager, SyncBase, SyncContextManager, mapping"
     )
-    print("NoneType = type(None)")
 
-    for t in all_types:
+    for t in generated_types:
         generate(t)
     documentation_provider.print_remainder()
 
diff --git a/scripts/postPdoc3Generation.js b/scripts/postPdoc3Generation.js
deleted file mode 100644
index 93fa6f96d..000000000
--- a/scripts/postPdoc3Generation.js
+++ /dev/null
@@ -1,7 +0,0 @@
-const fs = require('fs');
-
-// Removes the sidebar on the landing page (/)
-const indexPath = 'htmldocs/playwright/index.html';
-let input = fs.readFileSync(indexPath).toString();
-input = input.replace(/<nav id="sidebar">.*<\/nav>/s, '');
-fs.writeFileSync(indexPath, input);
diff --git a/scripts/report_downstream_test_diffs.py b/scripts/report_downstream_test_diffs.py
deleted file mode 100644
index 453928cd6..000000000
--- a/scripts/report_downstream_test_diffs.py
+++ /dev/null
@@ -1,106 +0,0 @@
-import argparse
-import json
-import os
-import re
-import subprocess
-import typing
-from collections import namedtuple
-
-from playwright._impl._path_utils import get_file_dirname
-
-_dirname = get_file_dirname()
-
-TestCase = namedtuple("TestCase", ["api", "file", "test"])
-
-
-def pytest_test_cases() -> typing.Generator[TestCase, None, None]:
-    p = subprocess.run(
-        ["pytest", "--browser", "chromium", "--collect-only", "-q"],
-        cwd=_dirname / ".." / "tests",
-        stdout=subprocess.PIPE,
-        check=True,
-    )
-    regex = (
-        r"tests/(?P<api>a?sync)/test_(?P<file>.*)\.py::test_(?P<test>.*)\[chromium\]"
-    )
-    matches = re.finditer(regex, p.stdout.decode(), re.MULTILINE)
-    for match in matches:
-        yield TestCase(
-            match.group("api"),
-            match.group("file"),
-            match.group("test"),
-        )
-
-
-def jest_test_cases(playwright_js_path: str) -> typing.Generator[TestCase, None, None]:
-    p = subprocess.run(
-        [
-            "node",
-            os.path.join("test", "runner"),
-            "test",
-            "--trial-run",
-            "--reporter",
-            "json",
-        ],
-        cwd=playwright_js_path,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.DEVNULL,
-        check=True,
-    )
-
-    tests = json.loads(p.stdout.decode())
-    for test in [*tests["pending"], *tests["passes"], *tests["failures"]]:
-        regex = r"(.*/)?(?P<file>[^/]+)\.spec\.[jt]s$"
-
-        match = re.match(regex, test["file"])
-        if not match:
-            continue
-
-        file = match.group("file")
-
-        yield TestCase("sync", normalized(file), normalized(test["title"]))
-        yield TestCase("async", normalized(file), normalized(test["title"]))
-
-
-def normalized(original: str) -> str:
-    cleaned = re.sub(r"[^a-z0-9_]", "_", original, flags=re.IGNORECASE)
-    cleaned = re.sub(r"[_]+", "_", cleaned)
-    cleaned = cleaned.strip("_")
-    return cleaned
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--playwright-js-path",
-        type=str,
-        help="path to playwright JavaScript directory",
-        required=True,
-    )
-    parser.add_argument(
-        "--api",
-        type=str,
-        help="filter test cases based on API",
-        choices=["sync", "async"],
-    )
-    args = parser.parse_args()
-
-    python_tests = set(pytest_test_cases())
-    javascript_tests = set(jest_test_cases(args.playwright_js_path))
-
-    if args.api:
-        javascript_tests = set([x for x in javascript_tests if x.api == args.api])
-
-    missing = javascript_tests.difference(python_tests)
-    found = javascript_tests.intersection(python_tests)
-
-    print("MISSING, MISPELLED, OR MISNAMED:")
-    print("=" * 80)
-    for (api, file, test) in sorted(missing):
-        print(f"{api}/test_{file}.py::test_{test}")
-
-    print(f"\nMissing: {len(missing)}, Found: {len(found)}")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/scripts/tag_image_and_push.sh b/scripts/tag_image_and_push.sh
deleted file mode 100755
index 9c5b09d2e..000000000
--- a/scripts/tag_image_and_push.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash
-
-echo "-- tagging: $2"
-docker tag $1 $2
-docker push $2
diff --git a/scripts/test_to_python.js b/scripts/test_to_python.js
deleted file mode 100755
index 83a13eecd..000000000
--- a/scripts/test_to_python.js
+++ /dev/null
@@ -1,164 +0,0 @@
-#!/usr/bin/env node
-/**
- * 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.
- */
-
-const fs = require('fs');
-
-(async () => {
-  const content = fs.readFileSync(process.argv[2]).toString();
-  const lines = content.split('\n');
-  for (let line of lines) {
-    if (line.trim().startsWith('describe')) {
-      console.log('# DESCRIBE ' + line)
-      continue;
-    }
-    if (line.trim() === '});') {
-      console.log('');
-      continue;
-    }
-
-    line = line.replace(/isWindows/g, 'is_win');
-    line = line.replace(/isLinux/g, 'is_linux');
-    line = line.replace(/isMac/g, 'is_mac');
-    line = line.replace(/isWebKit/g, 'is_webkit');
-    line = line.replace(/isChromium/g, 'is_chromium');
-    line = line.replace(/isFirefox/g, 'is_firefox');
-
-    let match = line.match(/it.*\(\'([^']+)\'.*async(?: function)?\s*\(\s*{(.*)}\s*\).*/);
-    if (match) {
-      console.log(`async def test_${match[1].replace(/[- =]|\[|\]|\>|\</g, '_')}(${match[2].trim()}):`);
-      continue;
-    }
-
-    line = line.replace(/;$/g, '');
-    line = line.replace(/ const /g, ' ');
-    line = line.replace(/ let /g, ' ');
-    line = line.replace(/\&\&/g, 'and');
-    line = line.replace(/\|\|/g, 'or');
-    line = line.replace(/'/g, '"');
-    line = line.replace(/ = null/g, ' = None');
-    line = line.replace(/===/g, '==');
-    line = line.replace('await Promise.all([', 'await asyncio.gather(');
-    line = line.replace(/\.\$\(/, '.querySelector(');
-    line = line.replace(/\.\$$\(/, '.querySelectorAll(');
-    line = line.replace(/\.\$eval\(/, '.evalOnSelector(');
-    line = line.replace(/\.\$$eval\(/, '.evalOnSelectorAll(');
-
-    match = line.match(/(\s+)expect\((.*)\).toEqual\((.*)\)/)
-    if (match)
-      line = `${match[1]}assert ${match[2]} == ${match[3]}`;
-    match = line.match(/(\s+)expect\((.*)\).toBe\((.*)\)/)
-      if (match)
-        line = `${match[1]}assert ${match[2]} == ${match[3]}`;
-    match = line.match(/(\s+)expect\((.*)\).toBeTruthy\((.*)\)/)
-    if (match)
-      line = `${match[1]}assert ${match[2]}`;
-    match = line.match(/(\s+)expect\((.*)\).toBeGreaterThan\((.*)\)/)
-    if (match)
-      line = `${match[1]}assert ${match[2]} > ${match[3]}`;
-
-    match = line.match(/(\s+)expect\((.*)\).toBeLessThan\((.*)\)/)
-    if (match)
-      line = `${match[1]}assert ${match[2]} < ${match[3]}`;
-
-    match = line.match(/(\s+)expect\((.*)\).toBeGreaterThanOrEqual\((.*)\)/)
-    if (match)
-      line = `${match[1]}assert ${match[2]} >= ${match[3]}`;
-
-    match = line.match(/(\s+)expect\((.*)\).toBeLessThanOrEqual\((.*)\)/)
-    if (match)
-      line = `${match[1]}assert ${match[2]} <= ${match[3]}`;
-
-    line = line.replace(/ false/g, ' False');
-    line = line.replace(/ true/g, ' True');
-
-    line = line.replace(/ == null/g, ' == None');
-    if (line.trim().startsWith('assert') && line.endsWith(' == True'))
-      line = line.substring(0, line.length - ' == True'.length);
-
-    // Quote evaluate
-    let index = line.indexOf('.evaluate(');
-    if (index !== -1) {
-      const tokens = [line.substring(0, index) + '.evaluate(\''];
-      let depth = 0;
-      for (let i = index + '.evaluate('.length; i < line.length; ++i) {
-        if (line[i] == '(')
-          ++depth;
-        if (line[i] == ')')
-          --depth;
-        if (depth < 0) {
-          tokens.push('\'' + line.substring(i));
-          break;
-        }
-        if (depth === 0 && line[i] === ',') {
-          tokens.push('\"' + line.substring(i));
-          break;
-        }
-        tokens.push(line[i]);
-      }
-      console.log(tokens.join(''));
-      continue;
-    }
-
-    // Name keys in the dict
-    index = line.indexOf('{');
-    if (index !== -1) {
-      let ok = false;
-      for (let i = index + 1; i < line.length; ++i) {
-        if (line[i] === '}') {
-          try {
-            console.log(line.substring(0, index) + JSON.stringify(eval('(' + line.substring(index, i + 1) + ')')).replace(/\"/g, '\'') + line.substring(i + 1));
-            ok = true;
-            break;
-          } catch (e) {
-          }
-        }
-      }
-      if (ok) continue;
-    }
-
-    // Single line template strings
-    index = line.indexOf('`');
-    if (index !== -1) {
-      const tokens = [line.substring(0, index) + '\''];
-      let ok = false;
-      for (let i = index + 1; i < line.length; ++i) {
-        if (line[i] === '`') {
-          tokens.push('\'' + line.substring(i + 1));
-          console.log(tokens.join(''));
-          ok = true;
-          break;
-        }
-        if (line[i] === '\'')
-          tokens.push('"');
-        else
-          tokens.push(line[i]);
-      }
-      if (ok) continue;
-    }
-
-    line = line.replace(/(\s+)/, '$1$1');
-    if (line.endsWith('{'))
-      line = line.substring(0, line.length - 1).trimEnd() + ':';
-      if (line.trim().startsWith('}'))
-      line = line.substring(0, line.indexOf('}')) + line.substring(line.indexOf('}') + 1).trim();
-    if (line.trim().startsWith('//'))
-      line = line.replace(/\/\//, '#');
-    if (!line.trim())
-      line = '';
-    console.log(line);
-  }
-})();
diff --git a/scripts/update_api.sh b/scripts/update_api.sh
index db2c291d6..616df730c 100755
--- a/scripts/update_api.sh
+++ b/scripts/update_api.sh
@@ -1,21 +1,24 @@
 #!/bin/bash
 
-python scripts/update_versions.py
-
 function update_api {
     echo "Generating $1"
     file_name="$1"
     generate_script="$2"
     git checkout HEAD -- "$file_name"
 
-    if python "$generate_script" > .x; then
+    if PYTHONIOENCODING=utf-8 python "$generate_script" > .x; then
         mv .x "$file_name"
         pre-commit run --files $file_name
         echo "Regenerated APIs"
     else
         echo "Exited due to errors"
+        exit 1
     fi
 }
 
 update_api "playwright/sync_api/_generated.py" "scripts/generate_sync_api.py"
 update_api "playwright/async_api/_generated.py" "scripts/generate_async_api.py"
+
+playwright install
+
+python scripts/update_versions.py
diff --git a/scripts/update_versions.py b/scripts/update_versions.py
index 6bd993ffd..50d8fff78 100644
--- a/scripts/update_versions.py
+++ b/scripts/update_versions.py
@@ -1,21 +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 re
+from pathlib import Path
 
 from playwright.sync_api import sync_playwright
 
-with sync_playwright() as p:
-    r = open("README.md", "r")
-    text = r.read()
-    for browser_type in [p.chromium, p.firefox, p.webkit]:
-        rx = re.compile(
-            r"<!-- GEN:" + browser_type.name + r"-version -->([^<]+)<!-- GEN:stop -->"
-        )
-        browser = browser_type.launch()
-        text = rx.sub(
-            f"<!-- GEN:{browser_type.name}-version -->{browser.version}<!-- GEN:stop -->",
-            text,
-        )
-        browser.close()
 
-    w = open("README.md", "w")
-    w.write(text)
-    w.close()
+def main() -> None:
+    with sync_playwright() as p:
+        readme = Path("README.md").resolve()
+        text = readme.read_text(encoding="utf-8")
+        for browser_type in [p.chromium, p.firefox, p.webkit]:
+            rx = re.compile(
+                r"<!-- GEN:"
+                + browser_type.name
+                + r"-version -->([^<]+)<!-- GEN:stop -->"
+            )
+            browser = browser_type.launch()
+            text = rx.sub(
+                f"<!-- GEN:{browser_type.name}-version -->{browser.version}<!-- GEN:stop -->",
+                text,
+            )
+            browser.close()
+        readme.write_text(text, encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/verify_api.sh b/scripts/verify_api.sh
deleted file mode 100755
index 565d14b9c..000000000
--- a/scripts/verify_api.sh
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-
-function assert_script {
-    newfile="$2"
-    oldfile="playwright/$2"
-    echo "Testing $newfile against $oldfile"
-
-    if ! python $1 > $newfile; then
-      exit 1
-    fi
-
-    pre-commit run --files $newfile
-
-    cmp $oldfile $newfile
-    exit_code=$?
-    rm $newfile
-}
-
-assert_script "scripts/generate_sync_api.py" "sync_api.py"
-assert_script "scripts/generate_async_api.py" "async_api.py"
diff --git a/setup.cfg b/setup.cfg
index 56a0babea..35d6f7007 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,25 +1,7 @@
-[tool:pytest]
-markers =
-    skip_browser
-    only_browser
-    skip_platform
-    only_platform
-junit_family=xunit2
-[mypy]
-ignore_missing_imports = True
-python_version = 3.7
-warn_unused_ignores = False
-warn_redundant_casts = True
-warn_unused_configs = True
-check_untyped_defs = True
-disallow_untyped_defs = True
-[mypy-tests.*]
-check_untyped_defs = False
-disallow_untyped_defs = False
 [flake8]
 ignore =
     E501
     W503
     E302
-[isort]
-profile = black
+    # Conflicts with black https://github.com/PyCQA/flake8/issues/1921
+    E704
diff --git a/setup.py b/setup.py
index feaf98376..89e1cda0a 100644
--- a/setup.py
+++ b/setup.py
@@ -14,113 +14,195 @@
 
 import glob
 import os
+import platform
 import shutil
-import stat
 import subprocess
 import sys
 import zipfile
+from pathlib import Path
+from typing import Dict
 
-import setuptools
-from wheel.bdist_wheel import bdist_wheel as BDistWheelCommand
+driver_version = "1.60.0"
 
-driver_version = "0.170.0-next.1608058598043"
+base_wheel_bundles = [
+    {
+        "wheel": "macosx_10_13_x86_64.whl",
+        "machine": "x86_64",
+        "platform": "darwin",
+        "zip_name": "mac",
+    },
+    {
+        "wheel": "macosx_11_0_universal2.whl",
+        "machine": "x86_64",
+        "platform": "darwin",
+        "zip_name": "mac",
+    },
+    {
+        "wheel": "macosx_11_0_arm64.whl",
+        "machine": "arm64",
+        "platform": "darwin",
+        "zip_name": "mac-arm64",
+    },
+    {
+        "wheel": "manylinux1_x86_64.whl",
+        "machine": "x86_64",
+        "platform": "linux",
+        "zip_name": "linux",
+    },
+    {
+        "wheel": "manylinux_2_17_aarch64.manylinux2014_aarch64.whl",
+        "machine": "aarch64",
+        "platform": "linux",
+        "zip_name": "linux-arm64",
+    },
+    {
+        "wheel": "win32.whl",
+        "machine": "i386",
+        "platform": "win32",
+        "zip_name": "win32_x64",
+    },
+    {
+        "wheel": "win_amd64.whl",
+        "machine": "amd64",
+        "platform": "win32",
+        "zip_name": "win32_x64",
+    },
+    {
+        "wheel": "win_arm64.whl",
+        "machine": "arm64",
+        "platform": "win32",
+        "zip_name": "win32_arm64",
+    },
+]
+
+if len(sys.argv) == 2 and sys.argv[1] == "--list-wheels":
+    for bundle in base_wheel_bundles:
+        print(bundle["wheel"])
+    exit(0)
 
+from setuptools import setup  # noqa: E402
 
-with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
+try:
+    from auditwheel.wheeltools import InWheel
+except ImportError:
+    InWheel = None
+from wheel.bdist_wheel import bdist_wheel as BDistWheelCommand  # noqa: E402
+
+
+def extractall(zip: zipfile.ZipFile, path: str) -> None:
+    for name in zip.namelist():
+        member = zip.getinfo(name)
+        extracted_path = zip.extract(member, path)
+        attr = member.external_attr >> 16
+        if attr != 0:
+            os.chmod(extracted_path, attr)
+
+
+def download_driver(zip_name: str) -> None:
+    zip_file = f"playwright-{driver_version}-{zip_name}.zip"
+    destination_path = "driver/" + zip_file
+    if os.path.exists(destination_path):
+        return
+    url = "https://cdn.playwright.dev/builds/driver/"
+    if (
+        "-alpha" in driver_version
+        or "-beta" in driver_version
+        or "-next" in driver_version
+    ):
+        url = url + "next/"
+    url = url + zip_file
+    temp_destination_path = destination_path + ".tmp"
+    print(f"Fetching {url}")
+    # Don't replace this with urllib - Python won't have certificates to do SSL on all platforms.
+    subprocess.check_call(["curl", url, "-o", temp_destination_path])
+    os.rename(temp_destination_path, destination_path)
 
 
 class PlaywrightBDistWheelCommand(BDistWheelCommand):
     def run(self) -> None:
-        if os.path.exists("build"):
-            shutil.rmtree("build")
-        if os.path.exists("dist"):
-            shutil.rmtree("dist")
-        if os.path.exists("playwright.egg-info"):
-            shutil.rmtree("playwright.egg-info")
         super().run()
         os.makedirs("driver", exist_ok=True)
         os.makedirs("playwright/driver", exist_ok=True)
-        for platform in ["mac", "linux", "win32", "win32_x64"]:
-            zip_file = f"playwright-cli-{driver_version}-{platform}.zip"
-            if not os.path.exists("driver/" + zip_file):
-                url = "https://playwright.azureedge.net/builds/cli/next/" + zip_file
-                print("Fetching ", url)
-                subprocess.check_call(
-                    ["curl", "--http1.1", url, "-o", "driver/" + zip_file]
+        self._download_and_extract_local_driver()
+
+        wheel = None
+        if os.getenv("PLAYWRIGHT_TARGET_WHEEL", None):
+            wheel = list(
+                filter(
+                    lambda wheel: wheel["wheel"]
+                    == os.getenv("PLAYWRIGHT_TARGET_WHEEL"),
+                    base_wheel_bundles,
                 )
-        base_wheel_location = glob.glob("dist/*.whl")[0]
+            )[0]
+        else:
+            wheel = list(
+                filter(
+                    lambda wheel: wheel["platform"] == sys.platform
+                    and wheel["machine"] == platform.machine().lower(),
+                    base_wheel_bundles,
+                )
+            )[0]
+        assert wheel
+        self._build_wheel(wheel)
+
+    def _build_wheel(
+        self,
+        wheel_bundle: Dict[str, str],
+    ) -> None:
+        assert self.dist_dir
+        base_wheel_location: str = glob.glob(os.path.join(self.dist_dir, "*.whl"))[0]
         without_platform = base_wheel_location[:-7]
-        platform_map = {
-            "darwin": "mac",
-            "linux": "linux",
-            "win32": "win32_x64" if sys.maxsize > 2 ** 32 else "win32",
-        }
-        for platform in ["mac", "linux", "win32", "win32_x64"]:
-            zip_file = f"driver/playwright-cli-{driver_version}-{platform}.zip"
-            with zipfile.ZipFile(zip_file, "r") as zip:
-                zip.extractall(f"driver/{platform}")
-            if platform_map[sys.platform] == platform:
-                with zipfile.ZipFile(zip_file, "r") as zip:
-                    zip.extractall("playwright/driver")
-                for file in os.listdir("playwright/driver"):
-                    if file == "playwright-cli" or file.startswith("ffmpeg"):
-                        print(f"playwright/driver/{file}")
-                        os.chmod(
-                            f"playwright/driver/{file}",
-                            os.stat(f"playwright/driver/{file}").st_mode | stat.S_IEXEC,
-                        )
-            wheel = ""
-            if platform == "mac":
-                wheel = "macosx_10_13_x86_64.whl"
-            if platform == "linux":
-                wheel = "manylinux1_x86_64.whl"
-            if platform == "win32":
-                wheel = "win32.whl"
-            if platform == "win32_x64":
-                wheel = "win_amd64.whl"
-            wheel_location = without_platform + wheel
-            shutil.copy(base_wheel_location, wheel_location)
-            with zipfile.ZipFile(wheel_location, "a") as zip:
-                for file in os.listdir(f"driver/{platform}"):
-                    from_location = f"driver/{platform}/{file}"
-                    to_location = f"playwright/driver/{file}"
-                    if file == "playwright-cli" or file.startswith("ffmpeg"):
-                        os.chmod(
-                            from_location, os.stat(from_location).st_mode | stat.S_IEXEC
-                        )
-                    zip.write(from_location, to_location)
+        download_driver(wheel_bundle["zip_name"])
+        zip_file = f"driver/playwright-{driver_version}-{wheel_bundle['zip_name']}.zip"
+        with zipfile.ZipFile(zip_file, "r") as zip:
+            extractall(zip, f"driver/{wheel_bundle['zip_name']}")
+        wheel_location = without_platform + wheel_bundle["wheel"]
+        shutil.copy(base_wheel_location, wheel_location)
+        with zipfile.ZipFile(
+            wheel_location, mode="a", compression=zipfile.ZIP_DEFLATED
+        ) as zip:
+            driver_root = os.path.abspath(f"driver/{wheel_bundle['zip_name']}")
+            for dir_path, _, files in os.walk(driver_root):
+                for file in files:
+                    from_path = os.path.join(dir_path, file)
+                    to_path = os.path.relpath(from_path, driver_root)
+                    zip.write(from_path, f"playwright/driver/{to_path}")
+            zip.writestr(
+                "playwright/driver/README.md",
+                f"{wheel_bundle['wheel']} driver package",
+            )
         os.remove(base_wheel_location)
+        for whlfile in glob.glob(os.path.join(self.dist_dir, "*.whl")):
+            os.makedirs("wheelhouse", exist_ok=True)
+            if InWheel:
+                wheelhouse_whl = os.path.join("wheelhouse", os.path.basename(whlfile))
+                shutil.move(whlfile, wheelhouse_whl)
+                with InWheel(in_wheel=Path(wheelhouse_whl), out_wheel=Path(whlfile)):
+                    print(f"Updating RECORD file of {whlfile}")
+        print("Copying new wheels")
+        shutil.rmtree("wheelhouse")
 
+    def _download_and_extract_local_driver(
+        self,
+    ) -> None:
+        zip_names_for_current_system = set(
+            map(
+                lambda wheel: wheel["zip_name"],
+                filter(
+                    lambda wheel: wheel["machine"] == platform.machine().lower()
+                    and wheel["platform"] == sys.platform,
+                    base_wheel_bundles,
+                ),
+            )
+        )
+        assert len(zip_names_for_current_system) == 1
+        zip_name = zip_names_for_current_system.pop()
+        download_driver(zip_name)
+        zip_file = f"driver/playwright-{driver_version}-{zip_name}.zip"
+        with zipfile.ZipFile(zip_file, "r") as zip:
+            extractall(zip, "playwright/driver")
 
-setuptools.setup(
-    name="playwright",
-    author="Microsoft Corporation",
-    author_email="",
-    description="A high-level API to automate web browsers",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/Microsoft/playwright-python",
-    packages=["playwright"],
-    include_package_data=True,
-    install_requires=["greenlet==1.0a1", "pyee>=8.0.1", "typing-extensions"],
-    classifiers=[
-        "Topic :: Software Development :: Testing",
-        "Topic :: Internet :: WWW/HTTP :: Browsers",
-        "Intended Audience :: Developers",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "License :: OSI Approved :: Apache Software License",
-        "Operating System :: OS Independent",
-    ],
-    python_requires=">=3.7",
+
+setup(
     cmdclass={"bdist_wheel": PlaywrightBDistWheelCommand},
-    use_scm_version={
-        "version_scheme": "post-release",
-        "write_to": "playwright/_repo_version.py",
-        "write_to_template": 'version = "{version}"\n',
-    },
-    setup_requires=["setuptools_scm"],
 )
diff --git a/tests/assets/client-certificates/README.md b/tests/assets/client-certificates/README.md
new file mode 100644
index 000000000..2c73bd92f
--- /dev/null
+++ b/tests/assets/client-certificates/README.md
@@ -0,0 +1,7 @@
+# Client Certificate test-certificates
+
+Regenerate all certificates by running:
+
+```
+bash generate.sh
+```
diff --git a/tests/assets/client-certificates/client/localhost/localhost.csr b/tests/assets/client-certificates/client/localhost/localhost.csr
new file mode 100644
index 000000000..cbf60ba43
--- /dev/null
+++ b/tests/assets/client-certificates/client/localhost/localhost.csr
@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIEizCCAnMCAQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MIICIjANBgkqhkiG9w0B
+AQEFAAOCAg8AMIICCgKCAgEAuxTIfOTWJzsLSYT/RXu6eUYe95oFA0gMM6pdQAws
+U08ufU8S68UzBIAb6zdwDqM6LD5FqLrwaTsUW73dKefb003EgA19L3sZTHSwnSv9
+g9+rnKw/8EA+1thFo7h3EfdWkO/nuxnPfEnHu5oxMk/mCu+hdjfgh01mxc00PIO/
+wioxZtuhzKNIUu+qQAj70Dwbkzy3Zb1QAnj+02AUYnrVTYhusmP4pjrfYgAWU1x4
+WN+XTSI27LnQHE8t8OxuICFwqEEPcJg4pCFNQgmO0gcRDbd4U7JgQ0xMXZ9na9k0
+f1GOgtjKsz5IIDrAwLnrIOEXiIYlNaQ/v28BrlWytaOHGFKmDxAbGXHz1WuftmR1
+vYQivC5fkXU3+QKWoGPZaLIhA7/ZOMSVgoo+Rv+mS6Mze/6LphatUMcI1oYX4ZBY
+FrsVsAeAO/FPZDcwVct0bdPCRRFBQpgl6DxMyItHMexNHwURi4YHwhYiBBe+Njc1
+tTh6dniA11MUVC5WmKME7CxgXxHVXE4MYcf/w1x4sOnxHneb1bCa8jOPELRc6byR
+8mk23fbBP42EPkrgpCtLhbHgskLKobLFav43xaIiYFn744U7rbINI+5RfJ8BH5Kw
+CB5RlAsymPxwDNcPXyyyeHEEUAQmtnJPrGPSGMN/QODgCWRXEvY556NGx0D5riu7
+MXkCAwEAAaAyMDAGCSqGSIb3DQEJDjEjMCEwHwYDVR0RBBgwFoIJbG9jYWxob3N0
+ggkxMjcuMC4wLjEwDQYJKoZIhvcNAQELBQADggIBAEYqpx28FFRHqXfyumTkkFb/
+hrlUD9qKUYSdjpsPLFRUYiLofNlYhCtEFEuHyLkNHqLO5Z6E7yOpm/HvdXY0eBQy
+tK0verggKXy8MnpLVtsFOf4DgenTwFRG3NbNk2/KynwiAwJ0iwOdDfAmwrzYFLeR
+uXysPE0lGJu277akuo/PDg3QEY44iDJgI4rqtY25sR8J23M9Roa5qN4bdaXl6l10
+UJhdugTG90gRFmmUVLLRa21A3j4m7pvWHu7zYJN7ylS/NQ6ZEnpNno7Ie6MLzrm6
+h8MOSoxtmrXi0e3aYf7PC3u3YLAjyUzHicgMdXk8SjtUXi6l3U5hU+6WBeOKKmwa
+vi+FUpRfnutkWpinNqikmMw0Sqy+bpXwbwgm2oD6driiMneBCT37gW/IyUPWVxzg
+dVgeQIt3i8SMwnGUrzfVo/gqjq4qFBpzS3h9jPPrMYQN2LQdmyo13R9UH26cLGE1
+cgVmqUKa11kX8353wfA36JuW5yGv2yaK4V1kwFISznMvk5AGdOHONdZOrN4sLIIY
+7Npqp5AO1KdoYcNVptCA4n6mN/30fTmA/W1ajsKcfIn5RlmvdgpooKoEgaU/X9RL
+d2ydIpijWbQqm+nF9skpO4jIFPfuQj6mMXCPWtsvbpHCoo0iMHHWfVFcpvsXGYN2
+6ji5z3opVapp1m5uTmcA
+-----END CERTIFICATE REQUEST-----
diff --git a/tests/assets/client-certificates/client/localhost/localhost.ext b/tests/assets/client-certificates/client/localhost/localhost.ext
new file mode 100644
index 000000000..d4d022726
--- /dev/null
+++ b/tests/assets/client-certificates/client/localhost/localhost.ext
@@ -0,0 +1 @@
+subjectAltName=DNS:localhost,DNS:127.0.0.1
diff --git a/tests/assets/client-certificates/client/localhost/localhost.key b/tests/assets/client-certificates/client/localhost/localhost.key
new file mode 100644
index 000000000..7f6adba53
--- /dev/null
+++ b/tests/assets/client-certificates/client/localhost/localhost.key
@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
diff --git a/tests/assets/client-certificates/client/localhost/localhost.pem b/tests/assets/client-certificates/client/localhost/localhost.pem
new file mode 100644
index 000000000..5c1a67505
--- /dev/null
+++ b/tests/assets/client-certificates/client/localhost/localhost.pem
@@ -0,0 +1,30 @@
+-----BEGIN CERTIFICATE-----
+MIIFKDCCAxCgAwIBAgIBATANBgkqhkiG9w0BAQsFADA2MRIwEAYDVQQDDAlsb2Nh
+bGhvc3QxIDAeBgNVBAoMF0NsaWVudCBDZXJ0aWZpY2F0ZSBEZW1vMB4XDTI1MDcy
+MTE1NTYxOVoXDTM1MDcxOTE1NTYxOVowFDESMBAGA1UEAwwJbG9jYWxob3N0MIIC
+IjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAuxTIfOTWJzsLSYT/RXu6eUYe
+95oFA0gMM6pdQAwsU08ufU8S68UzBIAb6zdwDqM6LD5FqLrwaTsUW73dKefb003E
+gA19L3sZTHSwnSv9g9+rnKw/8EA+1thFo7h3EfdWkO/nuxnPfEnHu5oxMk/mCu+h
+djfgh01mxc00PIO/wioxZtuhzKNIUu+qQAj70Dwbkzy3Zb1QAnj+02AUYnrVTYhu
+smP4pjrfYgAWU1x4WN+XTSI27LnQHE8t8OxuICFwqEEPcJg4pCFNQgmO0gcRDbd4
+U7JgQ0xMXZ9na9k0f1GOgtjKsz5IIDrAwLnrIOEXiIYlNaQ/v28BrlWytaOHGFKm
+DxAbGXHz1WuftmR1vYQivC5fkXU3+QKWoGPZaLIhA7/ZOMSVgoo+Rv+mS6Mze/6L
+phatUMcI1oYX4ZBYFrsVsAeAO/FPZDcwVct0bdPCRRFBQpgl6DxMyItHMexNHwUR
+i4YHwhYiBBe+Njc1tTh6dniA11MUVC5WmKME7CxgXxHVXE4MYcf/w1x4sOnxHneb
+1bCa8jOPELRc6byR8mk23fbBP42EPkrgpCtLhbHgskLKobLFav43xaIiYFn744U7
+rbINI+5RfJ8BH5KwCB5RlAsymPxwDNcPXyyyeHEEUAQmtnJPrGPSGMN/QODgCWRX
+EvY556NGx0D5riu7MXkCAwEAAaNjMGEwHwYDVR0RBBgwFoIJbG9jYWxob3N0ggkx
+MjcuMC4wLjEwHQYDVR0OBBYEFIE6kbIR0PlzaJuZg52JqXuFFQHBMB8GA1UdIwQY
+MBaAFPHaEfjJoIftSkHTb8mwme27LtifMA0GCSqGSIb3DQEBCwUAA4ICAQB7E57H
+19qUD4DjLxJGAVpDphD8mZg9aR7bUd6laXZ12VQnn3+OrF+6JjJ2TIr8ssRkkzc6
+rMhRqob+DxeB94JqlFQDmwP37wJXnuTtuGj71NHQal15b5ZB28fFdwWgUlYECWyg
+sYeMK5HMnNDziniRnjPoKU6f8urmUW2G8N2SOufnRar/StY/8u24IFh/vDTVJKWB
+a22pVk/PIx6JcErfMx0OJdoIUZd/C9DT/a7t+Pt+t3EPVNM2fcjs9aMcg6tlU6Tp
+YwHMzkFQYmcrp2QEhwy23z2E+wnLbeHTULDsHVOLudUGDcSgkW48bPNTOtZTysQ+
+P4mJf+Ju2HC/EwuVrOa14uuay9c+hC1Q1gsGbLZB8NE6jOX5QYN2a7iiUEdCdufo
+wWIXEC+2dJiEji3ehwJp0q4jK15X0IOIfxLH4PholORH659DdCfpm7YAjoaPE9nr
+28MMd9Lj6zWmfyeb5p0IUDpkreL2huxjXHJkmSm4dcxDxLqsP6KSPlhrPvjAVUqw
+5M/jUarDAHaPLNlwqcqWODb891FIyRmc6YHtSRGujMyfJ8LRS2f9rHeyM3m2jMHf
+8EahOgyQ8nvSs/a42VS97IHkGl6qufK7ZUq/VMhQRb+KbaIDN5TLtNwEQ1I40Bm9
+UOoSX/uP1PstOZvf9gnYto8sf75B+PxO692uYw==
+-----END CERTIFICATE-----
diff --git a/tests/assets/client-certificates/client/self-signed/cert.pem b/tests/assets/client-certificates/client/self-signed/cert.pem
new file mode 100644
index 000000000..d14ac95b2
--- /dev/null
+++ b/tests/assets/client-certificates/client/self-signed/cert.pem
@@ -0,0 +1,28 @@
+-----BEGIN CERTIFICATE-----
+MIIEyzCCArOgAwIBAgIUUo60oaPj20QM6oeGSn+2CT5j7GYwDQYJKoZIhvcNAQEL
+BQAwDjEMMAoGA1UEAwwDQm9iMB4XDTI1MDcyMTE1NTYyMFoXDTM1MDcxOTE1NTYy
+MFowDjEMMAoGA1UEAwwDQm9iMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKC
+AgEAzQMXYOZz3ILrbF9qpDng2pw2wJf1UFopehwaYyu7riWJ9+ADrhSnCSFBM3Sc
+MBc/8dIR6etWwci8QwJ/MtvIU0yx4llq+53G+19Bc1teC6q/b4QCRDIcTGxOZoR+
+jfYZVjPODEyJ5y5MZIo34ZP4bu+JnpT4W7+uojm3jOoyNPqXMcc70uAhfSKG+Jfr
+wZKteA4T5VKFytVcWgh4v03z8zTYeW3kD4lCsongBz6yu2dn3D6XMROnxiPwi+IR
+QqX1pwnJ0UA3CTeOHEw1jA3koxWIIg44PWaPaCj9Udrhf4ew00XLPWVZP8T5rVf8
+yUfecWQCR7FueJFqoLhPMMFi17rYmGZUvw3/YkXBjay4Q9e+G2WS3Xk8u+I1sCuV
+BJNBRv9DqtMC9D/N9NI8GkLrXwZmk82SXG+cQ0TSkNUHYI/03YKoqsn5H8PsG7Tc
++Y2Ca6TaCWims7lvOg7U0E6lu2h5NGcdWHFPJ9qfe+xho/yfYYwGqEKanGAu1kd5
+SbIaX6/YiM5/Pp/96MeRNrB9kLzDnZTNuGtdCawVFgbkWmfX2Z6/a0d6SvZGDzBx
+xTVZRB0my01E1FP53MS8YRH98HUjGEwNRVq2e1W+aXldKppgZ85GZD3l2YTeuI0i
+PJCDUzQiaWzFtWc8s13YQ1HLCOyOXF7QqMyNCiLGb4xQ56kCAwEAAaMhMB8wHQYD
+VR0OBBYEFMqdCDxkZm8HxNI4MLLveAVTdH7UMA0GCSqGSIb3DQEBCwUAA4ICAQAB
+MKd3WEJ8zI51FuyeTcMq6L1zk2vmKTFg6T7HZJhNZoD1AYvvsKJ8mrqeSwhxqjlE
+0H2FGLY+Z8Fw3+TE1QuvTuz3gwRI+yzBEyqi/fEGCGrhOVcWaXGgLCtWG+BA4Su8
+HenK97/n3OnXUnBozRPZMH02IaLrOiEGbpaabXKCCabpm5U1oGq437e3SeAeIL7U
+WxuHhHBx0yo9j7ACaCL6mz8xpk8NaRZpPy22MTlrPKwbOK2eYf3Jy5fHa/f6edTs
+KqZewI7t4oe/OqKdjyTgGYkjTE3Xcmo2T/fmcAeEP3HJX267kCzBi5J3McwonWxD
+N8zz9qKSf5YGQy140eEOTjjESwlPz6zfrTW92YdCIr63k9UCDL2HGQTRSxB6g4BQ
+loVzKS9/BKhulGqvSGvEoj6D+qG/PgFlBtJoE71X+vSIxvdbnOVmOi/l+NGNuP1Z
+nwnDtZWp4BKshhSKvqeOI+EyNMQ4FL20S4w8T+LR873jKrbd2MEuAsJiygWh+/ZJ
+haHTEhFxvH/a4i8gb/SGZlFB6oyPJ+XM5kZo4fcp7PnzxhYrIaEpPq+AR/3657hm
+AajXpS5lTCkNJc85QeHHj/0geDsOvfK4XUj2lgaJ0gXpgsoxnSCSq6Xox6ZqAVON
+0ra1KkGBTQH+5DxJ2Gp1UBaucrLYZTfXuJ8fPYeeNQ==
+-----END CERTIFICATE-----
diff --git a/tests/assets/client-certificates/client/self-signed/csr.pem b/tests/assets/client-certificates/client/self-signed/csr.pem
new file mode 100644
index 000000000..283dd45a6
--- /dev/null
+++ b/tests/assets/client-certificates/client/self-signed/csr.pem
@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIEUzCCAjsCAQAwDjEMMAoGA1UEAwwDQm9iMIICIjANBgkqhkiG9w0BAQEFAAOC
+Ag8AMIICCgKCAgEAzQMXYOZz3ILrbF9qpDng2pw2wJf1UFopehwaYyu7riWJ9+AD
+rhSnCSFBM3ScMBc/8dIR6etWwci8QwJ/MtvIU0yx4llq+53G+19Bc1teC6q/b4QC
+RDIcTGxOZoR+jfYZVjPODEyJ5y5MZIo34ZP4bu+JnpT4W7+uojm3jOoyNPqXMcc7
+0uAhfSKG+JfrwZKteA4T5VKFytVcWgh4v03z8zTYeW3kD4lCsongBz6yu2dn3D6X
+MROnxiPwi+IRQqX1pwnJ0UA3CTeOHEw1jA3koxWIIg44PWaPaCj9Udrhf4ew00XL
+PWVZP8T5rVf8yUfecWQCR7FueJFqoLhPMMFi17rYmGZUvw3/YkXBjay4Q9e+G2WS
+3Xk8u+I1sCuVBJNBRv9DqtMC9D/N9NI8GkLrXwZmk82SXG+cQ0TSkNUHYI/03YKo
+qsn5H8PsG7Tc+Y2Ca6TaCWims7lvOg7U0E6lu2h5NGcdWHFPJ9qfe+xho/yfYYwG
+qEKanGAu1kd5SbIaX6/YiM5/Pp/96MeRNrB9kLzDnZTNuGtdCawVFgbkWmfX2Z6/
+a0d6SvZGDzBxxTVZRB0my01E1FP53MS8YRH98HUjGEwNRVq2e1W+aXldKppgZ85G
+ZD3l2YTeuI0iPJCDUzQiaWzFtWc8s13YQ1HLCOyOXF7QqMyNCiLGb4xQ56kCAwEA
+AaAAMA0GCSqGSIb3DQEBCwUAA4ICAQAn/ZI7IkBUEfhZHefwtF+QHCyxSEKvqwHq
+fSqKVdarBPz8Ik8m3icj8R/DcS3y5jgzx3x8bXQoDpgsAQgeb825NRv2wAQAGoH1
+8vh204lTyjqzrgtK7eQeQDc7fjeigIkxQsAK9zk4BaFUWp0wEC0RLVAgvlQTl7vu
+n1jSSrhK8tvGy62/cIxZfwD0bAMHlW4m1A4fUuSGWQX2KldgA8tnmT6wx0If/nKb
+VB68AMbyMHUeb32v9wEvx2nHlwMjqNFeg7vYyJXOfBdDILUl+OTBoQY1X+jSx5iM
+txTzmA8Hcgx0Fq+BnbQuZCLqFpNWEfenAtQtaAFuJwMiKCf6kgbqkDVShJkmt+vC
+j3dcsVMZDsdMk4qRpiJhaTQOYmsMGCj4uoDpFGjwPoUwlDkjYgHAAsm9uCkshc+m
+WZO7I6Z3Tbi3XskJvAMc3dTWjtc6nApEtr/mn8LcETfOp7RRSfjllj6ijWUrVwUy
+BpzU9C/zLTkhFX0DVDCIV+jEefF8JPfzSKLgXyRbInTz1/6/sKXtswXW0NjzqLMI
+C9ggMBhOiDv9KJn3G/mY4CqIfo9KMzF+++4t+wdXTir8DWNlMUAn1vlBwxZAgKCM
+GonVExBU0VIGCpyTRLkesEHnPMgybP6gLzP3++54x288OS5JwuPPtkDcsBHUjTq8
+HxTJvUul/Q==
+-----END CERTIFICATE REQUEST-----
diff --git a/tests/assets/client-certificates/client/self-signed/key.pem b/tests/assets/client-certificates/client/self-signed/key.pem
new file mode 100644
index 000000000..c3ddd1a91
--- /dev/null
+++ b/tests/assets/client-certificates/client/self-signed/key.pem
@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
diff --git a/tests/assets/client-certificates/client/trusted/cert-legacy.pfx b/tests/assets/client-certificates/client/trusted/cert-legacy.pfx
new file mode 100644
index 000000000..9f06aa35c
Binary files /dev/null and b/tests/assets/client-certificates/client/trusted/cert-legacy.pfx differ
diff --git a/tests/assets/client-certificates/client/trusted/cert.pem b/tests/assets/client-certificates/client/trusted/cert.pem
new file mode 100644
index 000000000..3430d063c
--- /dev/null
+++ b/tests/assets/client-certificates/client/trusted/cert.pem
@@ -0,0 +1,29 @@
+-----BEGIN CERTIFICATE-----
+MIIFAzCCAuugAwIBAgIBATANBgkqhkiG9w0BAQsFADA2MRIwEAYDVQQDDAlsb2Nh
+bGhvc3QxIDAeBgNVBAoMF0NsaWVudCBDZXJ0aWZpY2F0ZSBEZW1vMB4XDTI1MDcy
+MTE1NTYxOFoXDTM1MDcxOTE1NTYxOFowEDEOMAwGA1UEAwwFQWxpY2UwggIiMA0G
+CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC4ggn74iAHLgOWOiOvB2CPe+Hr7W6S
+TYJLZOoqPdh7mv7QGm8cYxfD+26p13aEaW4/qn45losWdEPPy2ZiVIF+kcOP0R4A
+qsB0w9UHT4WSzCWtDqs8ywDMJ6tHge0++8S1bTpdutn/m8DPnKtkD9RQUzLFmGDO
++mB08Xu+egTzJvURbHXRJ27E+CXUXLEHbAJd8EKjJiQYXhcj4lzUXOUg+xkpPAGe
+1dgQ6BDkv3xq/81S9NTIT5YriHEm6egi9AFJLZbbZtCpRQm1MDMq7zfD7oL6ECLG
+rJ/aaxLEM49gMdw2SscYHotVxX2OMAKgN/ytB18L/mIQ4pOWp3HJQ+nks9Zu1V8c
+g7Pz5pWwjqoncbyUaBi3vGsitAot3cyLXbN9hH8zQB8QqGyNLvqQnCJOBlYxOPA8
+M8NQGDThWKspcix0LhkmnYsWWt3+KEGEpFRcJCEthm/DAd1GImP7/dg1/btT/zOs
+IIkIoCyBwznuR4M4XoNTbIBsiTnO/6PjOdTrjLVX7vMueTjdbCgK3VeOuwetbZ7a
+Z/hvMJCjJ4wuM3l2ZyfEQlP4gJLJS3Fw2PRsySZJl9JyEzwTqYVosDF5SF8uw0HI
+cFaliZCqBbgYfOiQzjIX/GiHZdor1ZrhAbO/MpSxuxGzxF7Em4n+4p816NnC9S2J
+bHRetkM9P1adHwIDAQABo0IwQDAdBgNVHQ4EFgQUXhGloOgfXb0tY7HZZGil/d11
+bcwwHwYDVR0jBBgwFoAU8doR+Mmgh+1KQdNvybCZ7bsu2J8wDQYJKoZIhvcNAQEL
+BQADggIBADNVu8YodDjB0474ztGSjV8WO0x984WQpGG6VPIt9xnnswNM8aOZVMNC
+AS12BjgviutSBUbL40xYNlytnqP0KtlgZSNpPVTGMAOoGttbgV7w46+hyBgV4hYs
+PsYrxMU1/4hTW/aGnNXpWJ4VwOESknSqUudzfy1mNVaEuPoL97SCvPrlKPU6El1a
+Wmove/QTKsbsjWaahqE59uClQ6CBcWbxpN5CLyIVM4c/UrsoXdwRewgXl19YFRzR
+l6LXBPid4UPQqdE6XIxgsNpoTDwAyxSRMPydlulJD5sSTaXHB7h63DsT9mEydjR3
+jPjhNZL5ADtDes3/UhfpXDbb8MudXdbdsHNswEl5ewAOdRXAuoaJuQ2TOnhz+cO0
+oaq9X3YaWjl8SwdvZrLIHLG3jEAQYEXDR+dEtT6vs7HmReMrYhGGoCEVrjSZAaeO
+9bQoSe0m8xbuSV19e5A+LZv3bcPcVOe91x/wnjVb98KRQcSQXCBE3yT5Oav/OLKZ
+TrdRkKe1yyPMHJiicn3pffdXuG6mIJC8HgYhvJEX/wkWf1BiyRd44dD1cgI1Ttt1
+pQoapJCmjA0XHtr15o4TW6hmnrmOOYTOVCCug8h1bWscBedMgdR5Qm+umbUiuC3N
+N6mxD49Sc40NCeDboX87rDiObhOXAAFsiE9o39z/tPToVa3TsJsA
+-----END CERTIFICATE-----
diff --git a/tests/assets/client-certificates/client/trusted/cert.pfx b/tests/assets/client-certificates/client/trusted/cert.pfx
new file mode 100644
index 000000000..391dea7b8
Binary files /dev/null and b/tests/assets/client-certificates/client/trusted/cert.pfx differ
diff --git a/tests/assets/client-certificates/client/trusted/csr.pem b/tests/assets/client-certificates/client/trusted/csr.pem
new file mode 100644
index 000000000..fc930ea7c
--- /dev/null
+++ b/tests/assets/client-certificates/client/trusted/csr.pem
@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIEVTCCAj0CAQAwEDEOMAwGA1UEAwwFQWxpY2UwggIiMA0GCSqGSIb3DQEBAQUA
+A4ICDwAwggIKAoICAQC4ggn74iAHLgOWOiOvB2CPe+Hr7W6STYJLZOoqPdh7mv7Q
+Gm8cYxfD+26p13aEaW4/qn45losWdEPPy2ZiVIF+kcOP0R4AqsB0w9UHT4WSzCWt
+Dqs8ywDMJ6tHge0++8S1bTpdutn/m8DPnKtkD9RQUzLFmGDO+mB08Xu+egTzJvUR
+bHXRJ27E+CXUXLEHbAJd8EKjJiQYXhcj4lzUXOUg+xkpPAGe1dgQ6BDkv3xq/81S
+9NTIT5YriHEm6egi9AFJLZbbZtCpRQm1MDMq7zfD7oL6ECLGrJ/aaxLEM49gMdw2
+SscYHotVxX2OMAKgN/ytB18L/mIQ4pOWp3HJQ+nks9Zu1V8cg7Pz5pWwjqoncbyU
+aBi3vGsitAot3cyLXbN9hH8zQB8QqGyNLvqQnCJOBlYxOPA8M8NQGDThWKspcix0
+LhkmnYsWWt3+KEGEpFRcJCEthm/DAd1GImP7/dg1/btT/zOsIIkIoCyBwznuR4M4
+XoNTbIBsiTnO/6PjOdTrjLVX7vMueTjdbCgK3VeOuwetbZ7aZ/hvMJCjJ4wuM3l2
+ZyfEQlP4gJLJS3Fw2PRsySZJl9JyEzwTqYVosDF5SF8uw0HIcFaliZCqBbgYfOiQ
+zjIX/GiHZdor1ZrhAbO/MpSxuxGzxF7Em4n+4p816NnC9S2JbHRetkM9P1adHwID
+AQABoAAwDQYJKoZIhvcNAQELBQADggIBACpScaAoLAs9DuTcI5Y4dbHf7LwF4Zxx
+UgPNzE1HB1Pr6NaHRiOWrlCtDEB5UwHrr0oZuRTqSEGg3Pe5Z2QtPG/sdFgfm4BP
+29o6qo0CXiEVBwU7/K0/lL2/0a7uSbD0Tkw9d6Bgik7/Z5rzXZIi2vtUcrOtHskP
+C+Z9w3vH9a+RnUeo52mCnRi4SaiSEnD5jvhmgaI9iF+k5pYBiMrKRj5W/F1QCkf4
+7OuSK97xN0eG/I4Oxgzi/qt51ySCYZbqoh7dIpwi/a4UsK8kdzDDI1M3J7bU07cO
+CJRfr0EETqCQw/gAKoag3tRFNvWQB6Z9G3Ev5jeaCLpcc32NlpN5xH3VW8A0Zb81
+dn5BXkPSxjwJaD0a3cLFkfgrasoe7ZMmHrVpQDw+9USuGCYXMPzNZLEeTFbrRkUn
+sqi30e28E1H69zVWj+OKzCWEH/azVlfaoVbwM+njUJDe5V09KvFtI7aZYmvLxbUX
+4ifoRUVoKedyKnueVmoIG57lF2VzeEhX5YjCngxIg+YuE99HkMQAZSlS6uJcVM92
+tsC/+pYECBk8ukenbxmKXROl3u4p2M1iCSL/8EOVROuyjnuzCXJZOpNptdpX4ZgL
+kHP1erq7/U8ZU8HviUsfMoisagx8dA8uj/4fk0jfNxOJqlZL9eJhpgBfYHqmAz3h
+m+PQVw96eeoK
+-----END CERTIFICATE REQUEST-----
diff --git a/tests/assets/client-certificates/client/trusted/key.pem b/tests/assets/client-certificates/client/trusted/key.pem
new file mode 100644
index 000000000..a11cdc8a7
--- /dev/null
+++ b/tests/assets/client-certificates/client/trusted/key.pem
@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
diff --git a/tests/assets/client-certificates/generate.sh b/tests/assets/client-certificates/generate.sh
new file mode 100755
index 000000000..f835f5f32
--- /dev/null
+++ b/tests/assets/client-certificates/generate.sh
@@ -0,0 +1,88 @@
+#!/bin/bash
+
+# Client Certificate test-certificates
+
+cd "$(dirname "$0")"
+
+## Server
+
+openssl req \
+	-x509 \
+	-newkey rsa:4096 \
+	-keyout server/server_key.pem \
+	-out server/server_cert.pem \
+	-nodes \
+	-days 3650 \
+	-subj "/CN=localhost/O=Client\ Certificate\ Demo" \
+	-addext "subjectAltName=DNS:localhost,DNS:local.playwright"
+
+## Trusted client-certificate (server signed/valid)
+
+mkdir -p client/trusted
+# generate server-signed (valid) certificate
+openssl req \
+	-newkey rsa:4096 \
+	-keyout client/trusted/key.pem \
+	-out client/trusted/csr.pem \
+	-nodes \
+	-days 3650 \
+	-subj "/CN=Alice"
+
+# sign with server_cert.pem
+openssl x509 \
+	-req \
+	-in client/trusted/csr.pem \
+	-CA server/server_cert.pem \
+	-CAkey server/server_key.pem \
+	-out client/trusted/cert.pem \
+	-set_serial 01 \
+	-days 3650
+# create pfx
+openssl pkcs12 -export -out client/trusted/cert.pfx -inkey client/trusted/key.pem -in client/trusted/cert.pem -passout pass:secure
+
+## Trusted certificate for localhost (server signed/valid)
+
+mkdir -p client/localhost
+
+# generate server-signed (valid) certificate
+openssl req \
+	-newkey rsa:4096 \
+	-keyout client/localhost/localhost.key \
+	-out client/localhost/localhost.csr \
+	-nodes \
+	-days 3650 \
+	-subj "/CN=localhost" \
+  -addext "subjectAltName=DNS:localhost,DNS:127.0.0.1"
+
+# put extensions
+echo "subjectAltName=DNS:localhost,DNS:127.0.0.1" > client/localhost/localhost.ext
+
+# sign with server_cert.pem
+openssl x509 \
+	-req \
+	-in client/localhost/localhost.csr \
+	-CA server/server_cert.pem \
+	-CAkey server/server_key.pem \
+	-set_serial 01 \
+	-out client/localhost/localhost.pem \
+	-days 3650 \
+  -extfile client/localhost/localhost.ext
+
+## Self-signed certificate (invalid)
+
+mkdir -p client/self-signed
+openssl req \
+	-newkey rsa:4096 \
+	-keyout client/self-signed/key.pem \
+	-out client/self-signed/csr.pem \
+	-nodes \
+	-days 3650 \
+	-subj "/CN=Bob"
+
+# sign with self-signed/key.pem
+openssl x509 \
+	-req \
+	-in client/self-signed/csr.pem \
+	-signkey client/self-signed/key.pem \
+	-out client/self-signed/cert.pem \
+	-days 3650
diff --git a/tests/assets/client-certificates/server/server_cert.pem b/tests/assets/client-certificates/server/server_cert.pem
new file mode 100644
index 000000000..18ee3d805
--- /dev/null
+++ b/tests/assets/client-certificates/server/server_cert.pem
@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFdTCCA12gAwIBAgIUFhAlW/DnHoHOFg2CXKBAvwYN4BIwDQYJKoZIhvcNAQEL
+BQAwNjESMBAGA1UEAwwJbG9jYWxob3N0MSAwHgYDVQQKDBdDbGllbnQgQ2VydGlm
+aWNhdGUgRGVtbzAeFw0yNTA3MjExNTU2MThaFw0zNTA3MTkxNTU2MThaMDYxEjAQ
+BgNVBAMMCWxvY2FsaG9zdDEgMB4GA1UECgwXQ2xpZW50IENlcnRpZmljYXRlIERl
+bW8wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDYDbBlM8ILtq2xKLFU
+ZwU4n7+0VHsO0skCfyNwpSZndbArjJUd/ZgFyCy5RK5Cg23KtXSMgkU6QlXOWvIr
+WJ/1wAkH9tuef/JDo9NJ00jBeua7HjdudNAsz6WwXSZC+a6DhA7nVHNwuyqq1SyH
+g5tuSP294EwfbEhXhaDyfXyBa4PaEmyjD2+O1NHSZ1AuUhblcUelKkZbykMvwCb7
+gJVXxlm/SN0K4vOVq80dBknr785562hDFGoXFX9hd2uPCQKbWGdMca+MmRWwNM2B
+CuxVoUl/Ooqmr7AdZ62lhpcqCd+todWC5GzrxwZjcIwt5P7MDvd+Ktmc8ePcZhp3
+L3ddlxXNgfi+c9OnZaz1QVgEn1YlDAmHvQtj9H+v2mmawyyRycjmhIpV/eaXaJvW
+A2wq+O2OERl056IjjzcXHrD6DOk7IjlTwQ87AMU4mNrCzW1LLd428OxQdGv2I4/b
+nq+0snOJOrTk65upybJYMGKUuTRqfEQgv5d/923VUISC69uTq+0zVFxG3pyMJR2D
+O+6xinBkp0Gk+ft9L4aaBAYXyUmi+PRSfdTfUk3yQkYefC55QTDDRK2rb7JiQqzr
+xhJ2vBar0TqXShQKKlMaOWHd+1U2ZjuyzboDDPeACoAmUVY2IHs+P8Dem0fwuKNd
+TF4jZkVQIWWLfTzzghOelmy9mwIDAQABo3sweTAdBgNVHQ4EFgQU8doR+Mmgh+1K
+QdNvybCZ7bsu2J8wHwYDVR0jBBgwFoAU8doR+Mmgh+1KQdNvybCZ7bsu2J8wDwYD
+VR0TAQH/BAUwAwEB/zAmBgNVHREEHzAdgglsb2NhbGhvc3SCEGxvY2FsLnBsYXl3
+cmlnaHQwDQYJKoZIhvcNAQELBQADggIBAH1/6Sp4dW96yvwi9ptgVRYfRSRWfYYy
+2nU6kJ1DPOW7hTPf2wLf6Z2KqiJXn8tECHfM4pnPSgDhtZHDDHAu9l7Diqzk/NIl
+AblRs++4vSKdnCx1uh3EFLjIMmHa/cRUzfuR+oGfri3v7jgTBV6UJJQ0pMqIDk/P
+VEOWWukllru40M8Rwy4F6LmpwIWMtNDxmhtXSbQJ6TZn+isNSoaWgHjQmayrVyXZ
+OcNYuR8M/ECvnufuIOW53+hhwG1X0jEoBdXqqXbTKcGjA+yLHp008AAB5DNQblYm
+FJ4N0v6eYLhOO0u3n0b/ZsqUkZx2h38tlZoAdJNqy+d4TE3WbGRNgNJrTjAOzpPL
+cQ5RNr3dDsUDFPnCoK3LUf9BWerARoDt+bbrM/VqvWH/0uqaU0/vo8IchSyQ9wGv
+SwrWLJU32HQUJ2VQP/m4ADf3X2Ozj+e8bBf7XPPD8KDyL4aR0KuYzrsOnhFlBkHD
+PtNjc7SgiE7AZe1WOEmhBQcr+vI6S8qFTurTntCBkvrFgYBAIIhK2XwFN5sFtByr
+GCB67NQMp37g2qFNYi8EmKQvPLpAcC3Je5PvHFSj2y9Z14FclGoxjU50SlH9/A5I
+iHGcIVjCv9NhNDFAwakF/sTnrpT/FIS7tm9GwoJGWCdYg4pl72WYCW6hJBG+XY7G
+t3jt9TP8623D
+-----END CERTIFICATE-----
diff --git a/tests/assets/client-certificates/server/server_key.pem b/tests/assets/client-certificates/server/server_key.pem
new file mode 100644
index 000000000..3a762bde7
--- /dev/null
+++ b/tests/assets/client-certificates/server/server_key.pem
@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
diff --git a/tests/assets/client.py b/tests/assets/client.py
new file mode 100644
index 000000000..670242f5d
--- /dev/null
+++ b/tests/assets/client.py
@@ -0,0 +1,34 @@
+# 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 sys
+from pathlib import Path
+
+from playwright.sync_api import Playwright, sync_playwright
+
+
+def main(playwright: Playwright, browser_name: str) -> None:
+    browser = playwright[browser_name].launch()
+    page = browser.new_page()
+    page.goto("data:text/html,Foobar")
+    here = Path(__file__).parent.resolve()
+    page.screenshot(path=here / f"{browser_name}.png")
+    page.close()
+    browser.close()
+
+
+if __name__ == "__main__":
+    browser_name = sys.argv[1]
+    with sync_playwright() as p:
+        main(p, browser_name)
diff --git a/tests/assets/dom.html b/tests/assets/dom.html
index 957b74e0c..d214becc5 100644
--- a/tests/assets/dom.html
+++ b/tests/assets/dom.html
@@ -1,2 +1,4 @@
 <div id="outer" name="value"><div id="inner">Text,
 more text</div></div><input id="check" type=checkbox checked foo="bar&quot;">
+<input id="input"></input>
+<textarea id="textarea"></textarea>
diff --git a/tests/assets/download-blob.html b/tests/assets/download-blob.html
index 02a08893b..3c4a3d813 100644
--- a/tests/assets/download-blob.html
+++ b/tests/assets/download-blob.html
@@ -24,6 +24,6 @@
       download("Hello world", "example.txt");
     }
     </script>
-    <a onclick="javascipt:downloadIt();">Download</a>
+    <a onclick="javascript:downloadIt();">Download</a>
   </body>
 </html>
diff --git a/tests/assets/drag-n-drop.html b/tests/assets/drag-n-drop.html
index 8189c4925..f43583e7c 100644
--- a/tests/assets/drag-n-drop.html
+++ b/tests/assets/drag-n-drop.html
@@ -28,7 +28,6 @@
   ev.preventDefault();
   var data = ev.dataTransfer.getData("text");
   ev.target.appendChild(document.getElementById(data));
-  ev.dataTransfer.clearData();
 }
 </script>
 
diff --git a/tests/assets/error.html b/tests/assets/error.html
index 26978c466..0851c4df8 100644
--- a/tests/assets/error.html
+++ b/tests/assets/error.html
@@ -1,4 +1,4 @@
-<script>
+<!DOCTYPE html> <script>
 console.error('Not a JS error');
 a();
 
@@ -11,8 +11,7 @@
 }
 
 function c() {
-    window.e = new Error('Fancy error!');
-    throw window.e;
+    throw new Error('Fancy error!');
 }
 //# sourceURL=myscript.js
 </script>
diff --git a/tests/assets/extension-mv3-simple/content-script.js b/tests/assets/extension-mv3-simple/content-script.js
new file mode 100644
index 000000000..0fd83b90f
--- /dev/null
+++ b/tests/assets/extension-mv3-simple/content-script.js
@@ -0,0 +1,2 @@
+console.log('hey from the content-script');
+self.thisIsTheContentScript = true;
diff --git a/tests/assets/extension-mv3-simple/index.js b/tests/assets/extension-mv3-simple/index.js
new file mode 100644
index 000000000..1523a8364
--- /dev/null
+++ b/tests/assets/extension-mv3-simple/index.js
@@ -0,0 +1,2 @@
+// Mock script for background extension
+globalThis.MAGIC = 42;
diff --git a/tests/assets/extension-mv3-simple/manifest.json b/tests/assets/extension-mv3-simple/manifest.json
new file mode 100644
index 000000000..39b77fc21
--- /dev/null
+++ b/tests/assets/extension-mv3-simple/manifest.json
@@ -0,0 +1,14 @@
+{
+  "name": "Simple extension",
+  "version": "0.1",
+  "background": {
+    "service_worker": "index.js"
+  },
+  "content_scripts": [{
+    "matches": ["<all_urls>"],
+    "css": [],
+    "js": ["content-script.js"]
+  }],
+  "permissions": ["background", "activeTab"],
+  "manifest_version": 3
+}
diff --git a/tests/assets/extension-mv3-with-logging/background.js b/tests/assets/extension-mv3-with-logging/background.js
new file mode 100644
index 000000000..3b1a406fb
--- /dev/null
+++ b/tests/assets/extension-mv3-with-logging/background.js
@@ -0,0 +1,5 @@
+console.log("Service worker script loaded");
+
+chrome.runtime.onInstalled.addListener(() => {
+  console.log("Extension installed");
+});
diff --git a/tests/assets/extension-mv3-with-logging/content.js b/tests/assets/extension-mv3-with-logging/content.js
new file mode 100644
index 000000000..e718206c2
--- /dev/null
+++ b/tests/assets/extension-mv3-with-logging/content.js
@@ -0,0 +1 @@
+console.log("Test console log from a third-party execution context");
diff --git a/tests/assets/extension-mv3-with-logging/manifest.json b/tests/assets/extension-mv3-with-logging/manifest.json
new file mode 100644
index 000000000..5ad1fde38
--- /dev/null
+++ b/tests/assets/extension-mv3-with-logging/manifest.json
@@ -0,0 +1,17 @@
+{
+    "manifest_version": 3,
+    "name": "Console Log Extension",
+    "version": "1.0",
+    "background": {
+      "service_worker": "background.js"
+    },
+    "permissions": [
+      "tabs"
+    ],
+    "content_scripts": [
+      {
+        "matches": ["<all_urls>"],
+        "js": ["content.js"]
+      }
+    ]
+  }
diff --git a/tests/assets/file-to-upload-2.txt b/tests/assets/file-to-upload-2.txt
new file mode 100644
index 000000000..2e2da2175
--- /dev/null
+++ b/tests/assets/file-to-upload-2.txt
@@ -0,0 +1 @@
+contents of the file
diff --git a/tests/assets/global-var.html b/tests/assets/global-var.html
new file mode 100644
index 000000000..52eb94e55
--- /dev/null
+++ b/tests/assets/global-var.html
@@ -0,0 +1,3 @@
+<script>
+  var globalVar = 123;
+</script>
diff --git a/tests/assets/har-fulfill.har b/tests/assets/har-fulfill.har
new file mode 100644
index 000000000..dc6b7c679
--- /dev/null
+++ b/tests/assets/har-fulfill.har
@@ -0,0 +1,366 @@
+{
+  "log": {
+    "version": "1.2",
+    "creator": {
+      "name": "Playwright",
+      "version": "1.23.0-next"
+    },
+    "browser": {
+      "name": "chromium",
+      "version": "103.0.5060.33"
+    },
+    "pages": [
+      {
+        "startedDateTime": "2022-06-10T04:27:32.125Z",
+        "id": "page@b17b177f1c2e66459db3dcbe44636ffd",
+        "title": "Hey",
+        "pageTimings": {
+          "onContentLoad": 70,
+          "onLoad": 70
+        }
+      }
+    ],
+    "entries": [
+      {
+        "_frameref": "frame@c7467fc0f1f86f09fc3b0d727a3862ea",
+        "_monotonicTime": 270572145.898,
+        "startedDateTime": "2022-06-10T04:27:32.146Z",
+        "time": 8.286,
+        "request": {
+          "method": "GET",
+          "url": "http://no.playwright/",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "Accept",
+              "value": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9"
+            },
+            {
+              "name": "Upgrade-Insecure-Requests",
+              "value": "1"
+            },
+            {
+              "name": "User-Agent",
+              "value": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.33 Safari/537.36"
+            }
+          ],
+          "queryString": [],
+          "headersSize": 326,
+          "bodySize": 0
+        },
+        "response": {
+          "status": 200,
+          "statusText": "OK",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "content-length",
+              "value": "111"
+            },
+            {
+              "name": "content-type",
+              "value": "text/html"
+            }
+          ],
+          "content": {
+            "size": 111,
+            "mimeType": "text/html",
+            "compression": 0,
+            "text": "<title>Hey</title><link rel='stylesheet' href='./style.css'><script src='./script.js'></script><div>hello</div>"
+          },
+          "headersSize": 65,
+          "bodySize": 170,
+          "redirectURL": "",
+          "_transferSize": 170
+        },
+        "cache": {
+          "beforeRequest": null,
+          "afterRequest": null
+        },
+        "timings": {
+          "dns": -1,
+          "connect": -1,
+          "ssl": -1,
+          "send": 0,
+          "wait": 8.286,
+          "receive": -1
+        },
+        "pageref": "page@b17b177f1c2e66459db3dcbe44636ffd",
+        "_securityDetails": {}
+      },
+      {
+        "_frameref": "frame@c7467fc0f1f86f09fc3b0d727a3862ea",
+        "_monotonicTime": 270572174.683,
+        "startedDateTime": "2022-06-10T04:27:32.172Z",
+        "time": 7.132,
+        "request": {
+          "method": "POST",
+          "url": "http://no.playwright/style.css",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "Accept",
+              "value": "text/css,*/*;q=0.1"
+            },
+            {
+              "name": "Referer",
+              "value": "http://no.playwright/"
+            },
+            {
+              "name": "User-Agent",
+              "value": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.33 Safari/537.36"
+            }
+          ],
+          "queryString": [],
+          "headersSize": 220,
+          "bodySize": 0
+        },
+        "response": {
+          "status": 200,
+          "statusText": "OK",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "content-length",
+              "value": "24"
+            },
+            {
+              "name": "content-type",
+              "value": "text/css"
+            }
+          ],
+          "content": {
+            "size": 24,
+            "mimeType": "text/css",
+            "compression": 0,
+            "text": "body { background:cyan }"
+          },
+          "headersSize": 63,
+          "bodySize": 81,
+          "redirectURL": "",
+          "_transferSize": 81
+        },
+        "cache": {
+          "beforeRequest": null,
+          "afterRequest": null
+        },
+        "timings": {
+          "dns": -1,
+          "connect": -1,
+          "ssl": -1,
+          "send": 0,
+          "wait": 8.132,
+          "receive": -1
+        },
+        "pageref": "page@b17b177f1c2e66459db3dcbe44636ffd",
+        "_securityDetails": {}
+      },
+      {
+        "_frameref": "frame@c7467fc0f1f86f09fc3b0d727a3862ea",
+        "_monotonicTime": 270572174.683,
+        "startedDateTime": "2022-06-10T04:27:32.174Z",
+        "time": 8.132,
+        "request": {
+          "method": "GET",
+          "url": "http://no.playwright/style.css",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "Accept",
+              "value": "text/css,*/*;q=0.1"
+            },
+            {
+              "name": "Referer",
+              "value": "http://no.playwright/"
+            },
+            {
+              "name": "User-Agent",
+              "value": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.33 Safari/537.36"
+            }
+          ],
+          "queryString": [],
+          "headersSize": 220,
+          "bodySize": 0
+        },
+        "response": {
+          "status": 200,
+          "statusText": "OK",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "content-length",
+              "value": "24"
+            },
+            {
+              "name": "content-type",
+              "value": "text/css"
+            }
+          ],
+          "content": {
+            "size": 24,
+            "mimeType": "text/css",
+            "compression": 0,
+            "text": "body { background: red }"
+          },
+          "headersSize": 63,
+          "bodySize": 81,
+          "redirectURL": "",
+          "_transferSize": 81
+        },
+        "cache": {
+          "beforeRequest": null,
+          "afterRequest": null
+        },
+        "timings": {
+          "dns": -1,
+          "connect": -1,
+          "ssl": -1,
+          "send": 0,
+          "wait": 8.132,
+          "receive": -1
+        },
+        "pageref": "page@b17b177f1c2e66459db3dcbe44636ffd",
+        "_securityDetails": {}
+      },
+      {
+        "_frameref": "frame@c7467fc0f1f86f09fc3b0d727a3862ea",
+        "_monotonicTime": 270572175.042,
+        "startedDateTime": "2022-06-10T04:27:32.175Z",
+        "time": 15.997,
+        "request": {
+          "method": "GET",
+          "url": "http://no.playwright/script.js",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "Accept",
+              "value": "*/*"
+            },
+            {
+              "name": "Referer",
+              "value": "http://no.playwright/"
+            },
+            {
+              "name": "User-Agent",
+              "value": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.33 Safari/537.36"
+            }
+          ],
+          "queryString": [],
+          "headersSize": 205,
+          "bodySize": 0
+        },
+        "response": {
+          "status": 301,
+          "statusText": "Moved Permanently",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "location",
+              "value": "http://no.playwright/script2.js"
+            }
+          ],
+          "content": {
+            "size": -1,
+            "mimeType": "x-unknown",
+            "compression": 0
+          },
+          "headersSize": 77,
+          "bodySize": 0,
+          "redirectURL": "http://no.playwright/script2.js",
+          "_transferSize": 77
+        },
+        "cache": {
+          "beforeRequest": null,
+          "afterRequest": null
+        },
+        "timings": {
+          "dns": -1,
+          "connect": -1,
+          "ssl": -1,
+          "send": 0,
+          "wait": 7.673,
+          "receive": 8.324
+        },
+        "pageref": "page@b17b177f1c2e66459db3dcbe44636ffd",
+        "_securityDetails": {}
+      },
+      {
+        "_frameref": "frame@c7467fc0f1f86f09fc3b0d727a3862ea",
+        "_monotonicTime": 270572181.822,
+        "startedDateTime": "2022-06-10T04:27:32.182Z",
+        "time": 6.735,
+        "request": {
+          "method": "GET",
+          "url": "http://no.playwright/script2.js",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "Accept",
+              "value": "*/*"
+            },
+            {
+              "name": "Referer",
+              "value": "http://no.playwright/"
+            },
+            {
+              "name": "User-Agent",
+              "value": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.33 Safari/537.36"
+            }
+          ],
+          "queryString": [],
+          "headersSize": 206,
+          "bodySize": 0
+        },
+        "response": {
+          "status": 200,
+          "statusText": "OK",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "content-length",
+              "value": "18"
+            },
+            {
+              "name": "content-type",
+              "value": "text/javascript"
+            }
+          ],
+          "content": {
+            "size": 18,
+            "mimeType": "text/javascript",
+            "compression": 0,
+            "text": "window.value='foo'"
+          },
+          "headersSize": 70,
+          "bodySize": 82,
+          "redirectURL": "",
+          "_transferSize": 82
+        },
+        "cache": {
+          "beforeRequest": null,
+          "afterRequest": null
+        },
+        "timings": {
+          "dns": -1,
+          "connect": -1,
+          "ssl": -1,
+          "send": 0,
+          "wait": 6.735,
+          "receive": -1
+        },
+        "pageref": "page@b17b177f1c2e66459db3dcbe44636ffd",
+        "_securityDetails": {}
+      }
+    ]
+  }
+}
diff --git a/tests/assets/har-redirect.har b/tests/assets/har-redirect.har
new file mode 100644
index 000000000..b2e573310
--- /dev/null
+++ b/tests/assets/har-redirect.har
@@ -0,0 +1,620 @@
+{
+  "log": {
+    "version": "1.2",
+    "creator": {
+      "name": "Playwright",
+      "version": "1.23.0-next"
+    },
+    "browser": {
+      "name": "chromium",
+      "version": "103.0.5060.42"
+    },
+    "pages": [
+      {
+        "startedDateTime": "2022-06-16T21:41:23.901Z",
+        "id": "page@8f314969edc000996eb5c2ab22f0e6b3",
+        "title": "Microsoft",
+        "pageTimings": {
+          "onContentLoad": 8363,
+          "onLoad": 8896
+        }
+      }
+    ],
+    "entries": [
+      {
+        "_frameref": "frame@3767e074ecde4cb8372abba2f6f9bb4f",
+        "_monotonicTime": 110928357.437,
+        "startedDateTime": "2022-06-16T21:41:23.951Z",
+        "time": 93.99,
+        "request": {
+          "method": "GET",
+          "url": "https://theverge.com/",
+          "httpVersion": "HTTP/2.0",
+          "cookies": [],
+          "headers": [
+            {
+              "name": ":authority",
+              "value": "theverge.com"
+            },
+            {
+              "name": ":method",
+              "value": "GET"
+            },
+            {
+              "name": ":path",
+              "value": "/"
+            },
+            {
+              "name": ":scheme",
+              "value": "https"
+            },
+            {
+              "name": "accept",
+              "value": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9"
+            },
+            {
+              "name": "accept-encoding",
+              "value": "gzip, deflate, br"
+            },
+            {
+              "name": "accept-language",
+              "value": "en-US,en;q=0.9"
+            },
+            {
+              "name": "sec-ch-ua",
+              "value": "\"Chromium\";v=\"103\", \".Not/A)Brand\";v=\"99\""
+            },
+            {
+              "name": "sec-ch-ua-mobile",
+              "value": "?0"
+            },
+            {
+              "name": "sec-ch-ua-platform",
+              "value": "\"Linux\""
+            },
+            {
+              "name": "sec-fetch-dest",
+              "value": "document"
+            },
+            {
+              "name": "sec-fetch-mode",
+              "value": "navigate"
+            },
+            {
+              "name": "sec-fetch-site",
+              "value": "none"
+            },
+            {
+              "name": "sec-fetch-user",
+              "value": "?1"
+            },
+            {
+              "name": "upgrade-insecure-requests",
+              "value": "1"
+            },
+            {
+              "name": "user-agent",
+              "value": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.42 Safari/537.36"
+            }
+          ],
+          "queryString": [],
+          "headersSize": 644,
+          "bodySize": 0
+        },
+        "response": {
+          "status": 301,
+          "statusText": "",
+          "httpVersion": "HTTP/2.0",
+          "cookies": [
+            {
+              "name": "vmidv1",
+              "value": "9faf31ab-1415-4b90-b367-24b670205f41",
+              "expires": "2027-06-15T21:41:24.000Z",
+              "domain": "theverge.com",
+              "path": "/",
+              "sameSite": "Lax",
+              "secure": true
+            }
+          ],
+          "headers": [
+            {
+              "name": "accept-ranges",
+              "value": "bytes"
+            },
+            {
+              "name": "content-length",
+              "value": "0"
+            },
+            {
+              "name": "date",
+              "value": "Thu, 16 Jun 2022 21:41:24 GMT"
+            },
+            {
+              "name": "location",
+              "value": "http://www.theverge.com/"
+            },
+            {
+              "name": "retry-after",
+              "value": "0"
+            },
+            {
+              "name": "server",
+              "value": "Varnish"
+            },
+            {
+              "name": "set-cookie",
+              "value": "vmidv1=9faf31ab-1415-4b90-b367-24b670205f41;Expires=Tue, 15 Jun 2027 21:41:24 GMT;Domain=theverge.com;Path=/;SameSite=Lax;Secure"
+            },
+            {
+              "name": "via",
+              "value": "1.1 varnish"
+            },
+            {
+              "name": "x-cache",
+              "value": "HIT"
+            },
+            {
+              "name": "x-cache-hits",
+              "value": "0"
+            },
+            {
+              "name": "x-served-by",
+              "value": "cache-pao17442-PAO"
+            },
+            {
+              "name": "x-timer",
+              "value": "S1655415684.005867,VS0,VE0"
+            }
+          ],
+          "content": {
+            "size": -1,
+            "mimeType": "x-unknown",
+            "compression": 0
+          },
+          "headersSize": 425,
+          "bodySize": 0,
+          "redirectURL": "http://www.theverge.com/",
+          "_transferSize": 425
+        },
+        "cache": {
+          "beforeRequest": null,
+          "afterRequest": null
+        },
+        "timings": {
+          "dns": 0,
+          "connect": 34.151,
+          "ssl": 28.074,
+          "send": 0,
+          "wait": 27.549,
+          "receive": 4.216
+        },
+        "pageref": "page@8f314969edc000996eb5c2ab22f0e6b3",
+        "serverIPAddress": "151.101.65.52",
+        "_serverPort": 443,
+        "_securityDetails": {
+          "protocol": "TLS 1.2",
+          "subjectName": "*.americanninjawarriornation.com",
+          "issuer": "GlobalSign Atlas R3 DV TLS CA 2022 Q1",
+          "validFrom": 1644853133,
+          "validTo": 1679153932
+        }
+      },
+      {
+        "_frameref": "frame@3767e074ecde4cb8372abba2f6f9bb4f",
+        "_monotonicTime": 110928427.603,
+        "startedDateTime": "2022-06-16T21:41:24.022Z",
+        "time": 44.39499999999999,
+        "request": {
+          "method": "GET",
+          "url": "http://www.theverge.com/",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "Accept",
+              "value": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9"
+            },
+            {
+              "name": "Accept-Encoding",
+              "value": "gzip, deflate"
+            },
+            {
+              "name": "Accept-Language",
+              "value": "en-US,en;q=0.9"
+            },
+            {
+              "name": "Connection",
+              "value": "keep-alive"
+            },
+            {
+              "name": "Host",
+              "value": "www.theverge.com"
+            },
+            {
+              "name": "Upgrade-Insecure-Requests",
+              "value": "1"
+            },
+            {
+              "name": "User-Agent",
+              "value": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.42 Safari/537.36"
+            }
+          ],
+          "queryString": [],
+          "headersSize": 423,
+          "bodySize": 0
+        },
+        "response": {
+          "status": 301,
+          "statusText": "Moved Permanently",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [
+            {
+              "name": "_chorus_geoip_continent",
+              "value": "NA"
+            },
+            {
+              "name": "vmidv1",
+              "value": "4e0c1265-10f8-4cb1-a5de-1c3cf70b531c",
+              "expires": "2027-06-15T21:41:24.000Z",
+              "domain": "www.theverge.com",
+              "path": "/",
+              "sameSite": "Lax",
+              "secure": true
+            }
+          ],
+          "headers": [
+            {
+              "name": "Accept-Ranges",
+              "value": "bytes"
+            },
+            {
+              "name": "Age",
+              "value": "2615"
+            },
+            {
+              "name": "Connection",
+              "value": "keep-alive"
+            },
+            {
+              "name": "Content-Length",
+              "value": "0"
+            },
+            {
+              "name": "Content-Type",
+              "value": "text/html"
+            },
+            {
+              "name": "Date",
+              "value": "Thu, 16 Jun 2022 21:41:24 GMT"
+            },
+            {
+              "name": "Location",
+              "value": "https://www.theverge.com/"
+            },
+            {
+              "name": "Server",
+              "value": "nginx"
+            },
+            {
+              "name": "Set-Cookie",
+              "value": "_chorus_geoip_continent=NA; expires=Fri, 17 Jun 2022 21:41:24 GMT; path=/;"
+            },
+            {
+              "name": "Set-Cookie",
+              "value": "vmidv1=4e0c1265-10f8-4cb1-a5de-1c3cf70b531c;Expires=Tue, 15 Jun 2027 21:41:24 GMT;Domain=www.theverge.com;Path=/;SameSite=Lax;Secure"
+            },
+            {
+              "name": "Vary",
+              "value": "X-Forwarded-Proto, Cookie, X-Chorus-Unison-Testing, X-Chorus-Require-Privacy-Consent, X-Chorus-Restrict-In-Privacy-Consent-Region, Accept-Encoding"
+            },
+            {
+              "name": "Via",
+              "value": "1.1 varnish"
+            },
+            {
+              "name": "X-Cache",
+              "value": "HIT"
+            },
+            {
+              "name": "X-Cache-Hits",
+              "value": "2"
+            },
+            {
+              "name": "X-Served-By",
+              "value": "cache-pao17450-PAO"
+            },
+            {
+              "name": "X-Timer",
+              "value": "S1655415684.035748,VS0,VE0"
+            }
+          ],
+          "content": {
+            "size": -1,
+            "mimeType": "text/html",
+            "compression": 0
+          },
+          "headersSize": 731,
+          "bodySize": 0,
+          "redirectURL": "https://www.theverge.com/",
+          "_transferSize": 731
+        },
+        "cache": {
+          "beforeRequest": null,
+          "afterRequest": null
+        },
+        "timings": {
+          "dns": 2.742,
+          "connect": 10.03,
+          "ssl": 14.123,
+          "send": 0,
+          "wait": 15.023,
+          "receive": 2.477
+        },
+        "pageref": "page@8f314969edc000996eb5c2ab22f0e6b3",
+        "serverIPAddress": "151.101.189.52",
+        "_serverPort": 80,
+        "_securityDetails": {}
+      },
+      {
+        "_frameref": "frame@3767e074ecde4cb8372abba2f6f9bb4f",
+        "_monotonicTime": 110928455.901,
+        "startedDateTime": "2022-06-16T21:41:24.050Z",
+        "time": 50.29199999999999,
+        "request": {
+          "method": "GET",
+          "url": "https://www.theverge.com/",
+          "httpVersion": "HTTP/2.0",
+          "cookies": [
+            {
+              "name": "vmidv1",
+              "value": "9faf31ab-1415-4b90-b367-24b670205f41"
+            },
+            {
+              "name": "_chorus_geoip_continent",
+              "value": "NA"
+            }
+          ],
+          "headers": [
+            {
+              "name": ":authority",
+              "value": "www.theverge.com"
+            },
+            {
+              "name": ":method",
+              "value": "GET"
+            },
+            {
+              "name": ":path",
+              "value": "/"
+            },
+            {
+              "name": ":scheme",
+              "value": "https"
+            },
+            {
+              "name": "accept",
+              "value": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9"
+            },
+            {
+              "name": "accept-encoding",
+              "value": "gzip, deflate, br"
+            },
+            {
+              "name": "accept-language",
+              "value": "en-US,en;q=0.9"
+            },
+            {
+              "name": "cookie",
+              "value": "vmidv1=9faf31ab-1415-4b90-b367-24b670205f41; _chorus_geoip_continent=NA"
+            },
+            {
+              "name": "sec-ch-ua",
+              "value": "\"Chromium\";v=\"103\", \".Not/A)Brand\";v=\"99\""
+            },
+            {
+              "name": "sec-ch-ua-mobile",
+              "value": "?0"
+            },
+            {
+              "name": "sec-ch-ua-platform",
+              "value": "\"Linux\""
+            },
+            {
+              "name": "sec-fetch-dest",
+              "value": "document"
+            },
+            {
+              "name": "sec-fetch-mode",
+              "value": "navigate"
+            },
+            {
+              "name": "sec-fetch-site",
+              "value": "none"
+            },
+            {
+              "name": "sec-fetch-user",
+              "value": "?1"
+            },
+            {
+              "name": "upgrade-insecure-requests",
+              "value": "1"
+            },
+            {
+              "name": "user-agent",
+              "value": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.42 Safari/537.36"
+            }
+          ],
+          "queryString": [],
+          "headersSize": 729,
+          "bodySize": 0
+        },
+        "response": {
+          "status": 200,
+          "statusText": "",
+          "httpVersion": "HTTP/2.0",
+          "cookies": [
+            {
+              "name": "_chorus_geoip_continent",
+              "value": "NA"
+            },
+            {
+              "name": "vmidv1",
+              "value": "40d8fd14-5ac3-4757-9e9c-efb106e82d3a",
+              "expires": "2027-06-15T21:41:24.000Z",
+              "domain": "www.theverge.com",
+              "path": "/",
+              "sameSite": "Lax",
+              "secure": true
+            }
+          ],
+          "headers": [
+            {
+              "name": "accept-ranges",
+              "value": "bytes"
+            },
+            {
+              "name": "age",
+              "value": "263"
+            },
+            {
+              "name": "cache-control",
+              "value": "max-age=0, public, must-revalidate"
+            },
+            {
+              "name": "content-encoding",
+              "value": "br"
+            },
+            {
+              "name": "content-length",
+              "value": "14"
+            },
+            {
+              "name": "content-security-policy",
+              "value": "default-src https: data: 'unsafe-inline' 'unsafe-eval'; child-src https: data: blob:; connect-src https: data: blob: ; font-src https: data:; img-src https: data: blob:; media-src https: data: blob:; object-src https:; script-src https: data: blob: 'unsafe-inline' 'unsafe-eval'; style-src https: 'unsafe-inline'; block-all-mixed-content; upgrade-insecure-requests"
+            },
+            {
+              "name": "content-type",
+              "value": "text/html; charset=utf-8"
+            },
+            {
+              "name": "date",
+              "value": "Thu, 16 Jun 2022 21:41:24 GMT"
+            },
+            {
+              "name": "etag",
+              "value": "W/\"d498ef668223d015000070a66a181e85\""
+            },
+            {
+              "name": "link",
+              "value": "<https://concertads-configs.vox-cdn.com/sbn/verge/config.json>; rel=preload; as=fetch; crossorigin"
+            },
+            {
+              "name": "referrer-policy",
+              "value": "strict-origin-when-cross-origin"
+            },
+            {
+              "name": "server",
+              "value": "nginx"
+            },
+            {
+              "name": "set-cookie",
+              "value": "_chorus_geoip_continent=NA; expires=Fri, 17 Jun 2022 21:41:24 GMT; path=/;"
+            },
+            {
+              "name": "set-cookie",
+              "value": "vmidv1=40d8fd14-5ac3-4757-9e9c-efb106e82d3a;Expires=Tue, 15 Jun 2027 21:41:24 GMT;Domain=www.theverge.com;Path=/;SameSite=Lax;Secure"
+            },
+            {
+              "name": "strict-transport-security",
+              "value": "max-age=31556952; preload"
+            },
+            {
+              "name": "vary",
+              "value": "Accept-Encoding, X-Chorus-Unison-Testing, X-Chorus-Require-Privacy-Consent, X-Chorus-Restrict-In-Privacy-Consent-Region, Origin, X-Forwarded-Proto, Cookie, X-Chorus-Unison-Testing, X-Chorus-Require-Privacy-Consent, X-Chorus-Restrict-In-Privacy-Consent-Region"
+            },
+            {
+              "name": "via",
+              "value": "1.1 varnish"
+            },
+            {
+              "name": "x-cache",
+              "value": "HIT"
+            },
+            {
+              "name": "x-cache-hits",
+              "value": "1"
+            },
+            {
+              "name": "x-content-type-options",
+              "value": "nosniff"
+            },
+            {
+              "name": "x-download-options",
+              "value": "noopen"
+            },
+            {
+              "name": "x-frame-options",
+              "value": "SAMEORIGIN"
+            },
+            {
+              "name": "x-permitted-cross-domain-policies",
+              "value": "none"
+            },
+            {
+              "name": "x-request-id",
+              "value": "97363ad70e272e63641c0bb784fa06a01b848dfd"
+            },
+            {
+              "name": "x-runtime",
+              "value": "0.257911"
+            },
+            {
+              "name": "x-served-by",
+              "value": "cache-pao17436-PAO"
+            },
+            {
+              "name": "x-timer",
+              "value": "S1655415684.075077,VS0,VE1"
+            },
+            {
+              "name": "x-xss-protection",
+              "value": "1; mode=block"
+            }
+          ],
+          "content": {
+            "size": 14,
+            "mimeType": "text/html",
+            "compression": 0,
+            "text": "<h1>hello</h1>"
+          },
+          "headersSize": 1742,
+          "bodySize": 48716,
+          "redirectURL": "",
+          "_transferSize": 48716
+        },
+        "cache": {
+          "beforeRequest": null,
+          "afterRequest": null
+        },
+        "timings": {
+          "dns": 0.016,
+          "connect": 24.487,
+          "ssl": 17.406,
+          "send": 0,
+          "wait": 8.383,
+          "receive": -1
+        },
+        "pageref": "page@8f314969edc000996eb5c2ab22f0e6b3",
+        "serverIPAddress": "151.101.189.52",
+        "_serverPort": 443,
+        "_securityDetails": {
+          "protocol": "TLS 1.2",
+          "subjectName": "*.americanninjawarriornation.com",
+          "issuer": "GlobalSign Atlas R3 DV TLS CA 2022 Q1",
+          "validFrom": 1644853133,
+          "validTo": 1679153932
+        }
+      }
+    ]
+  }
+}
diff --git a/tests/assets/har-sha1-main-response.txt b/tests/assets/har-sha1-main-response.txt
new file mode 100644
index 000000000..dbe9dba55
--- /dev/null
+++ b/tests/assets/har-sha1-main-response.txt
@@ -0,0 +1 @@
+Hello, world
\ No newline at end of file
diff --git a/tests/assets/har-sha1.har b/tests/assets/har-sha1.har
new file mode 100644
index 000000000..850b06dd8
--- /dev/null
+++ b/tests/assets/har-sha1.har
@@ -0,0 +1,95 @@
+{
+  "log": {
+    "version": "1.2",
+    "creator": {
+      "name": "Playwright",
+      "version": "1.23.0-next"
+    },
+    "browser": {
+      "name": "chromium",
+      "version": "103.0.5060.33"
+    },
+    "pages": [
+      {
+        "startedDateTime": "2022-06-10T04:27:32.125Z",
+        "id": "page@b17b177f1c2e66459db3dcbe44636ffd",
+        "title": "Hey",
+        "pageTimings": {
+          "onContentLoad": 70,
+          "onLoad": 70
+        }
+      }
+    ],
+    "entries": [
+      {
+        "_frameref": "frame@c7467fc0f1f86f09fc3b0d727a3862ea",
+        "_monotonicTime": 270572145.898,
+        "startedDateTime": "2022-06-10T04:27:32.146Z",
+        "time": 8.286,
+        "request": {
+          "method": "GET",
+          "url": "http://no.playwright/",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "Accept",
+              "value": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9"
+            },
+            {
+              "name": "Upgrade-Insecure-Requests",
+              "value": "1"
+            },
+            {
+              "name": "User-Agent",
+              "value": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.33 Safari/537.36"
+            }
+          ],
+          "queryString": [],
+          "headersSize": 326,
+          "bodySize": 0
+        },
+        "response": {
+          "status": 200,
+          "statusText": "OK",
+          "httpVersion": "HTTP/1.1",
+          "cookies": [],
+          "headers": [
+            {
+              "name": "content-length",
+              "value": "12"
+            },
+            {
+              "name": "content-type",
+              "value": "text/html"
+            }
+          ],
+          "content": {
+            "size": 12,
+            "mimeType": "text/html",
+            "compression": 0,
+            "_file": "har-sha1-main-response.txt"
+          },
+          "headersSize": 64,
+          "bodySize": 71,
+          "redirectURL": "",
+          "_transferSize": 71
+        },
+        "cache": {
+          "beforeRequest": null,
+          "afterRequest": null
+        },
+        "timings": {
+          "dns": -1,
+          "connect": -1,
+          "ssl": -1,
+          "send": 0,
+          "wait": 8.286,
+          "receive": -1
+        },
+        "pageref": "page@b17b177f1c2e66459db3dcbe44636ffd",
+        "_securityDetails": {}
+      }
+    ]
+  }
+}
diff --git a/tests/assets/headings.html b/tests/assets/headings.html
new file mode 100644
index 000000000..ba770fa4e
--- /dev/null
+++ b/tests/assets/headings.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <title>Headings</title>
+</head>
+
+<body>
+    <h1>Title</h1>
+    <h2>Subtitle</h2>
+    <h3>Subsubtitle</h3>
+    <h2>Subtitle</h2>
+</body>
+
+</html>
diff --git a/tests/assets/input/fileupload-multi.html b/tests/assets/input/fileupload-multi.html
new file mode 100644
index 000000000..05dd5a223
--- /dev/null
+++ b/tests/assets/input/fileupload-multi.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>File upload test</title>
+  </head>
+  <body>
+    <form action="/upload" method="post" enctype="multipart/form-data">
+      <input type="file" multiple name="file1">
+      <input type="submit">
+    </form>
+  </body>
+</html>
diff --git a/tests/assets/input/fileupload.html b/tests/assets/input/fileupload.html
index 57e90d50a..771dc4c68 100644
--- a/tests/assets/input/fileupload.html
+++ b/tests/assets/input/fileupload.html
@@ -4,8 +4,8 @@
     <title>File upload test</title>
   </head>
   <body>
-    <form action="/input/fileupload.html">
-      <input type="file">
+    <form action="/upload" method="post" enctype="multipart/form-data">
+      <input type="file" name="file1">
       <input type="submit">
     </form>
   </body>
diff --git a/tests/assets/input/folderupload.html b/tests/assets/input/folderupload.html
new file mode 100644
index 000000000..b6a2693b7
--- /dev/null
+++ b/tests/assets/input/folderupload.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Folder upload test</title>
+  </head>
+  <body>
+    <form action="/upload" method="post" enctype="multipart/form-data">
+      <input type="file" name="file1" webkitdirectory>
+      <input type="submit">
+    </form>
+  </body>
+</html>
diff --git a/tests/assets/input/handle-locator.html b/tests/assets/input/handle-locator.html
new file mode 100644
index 000000000..f8f2111c9
--- /dev/null
+++ b/tests/assets/input/handle-locator.html
@@ -0,0 +1,91 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Interstitial test</title>
+  </head>
+  <body>
+    <style>
+      body {
+        position: relative;
+      }
+      #target.removed {
+        display: none;
+      }
+      #target.hidden {
+        visibility: hidden;
+      }
+      #target:hover {
+        background: yellow;
+      }
+      #interstitial {
+        position: absolute;
+        top: 0;
+        left: 0;
+        width: 300px;
+        height: 300px;
+        border: 1px solid black;
+        background: rgba(255, 180, 180);
+        display: none;
+      }
+      #interstitial.visible {
+        display: block;
+      }
+      #close {
+        margin: 50px;
+      }
+    </style>
+    <div><button id="target">Click me</button></div>
+    <div id="aside">A place on the side to hover</div>
+    <div id="interstitial">
+      <div>This interstitial covers the button</div>
+      <button id="close">Close the interstitial</button>
+    </div>
+    <script>
+      const target = document.querySelector('#target');
+      const interstitial = document.querySelector('#interstitial');
+      const close = document.querySelector('#close');
+
+      target.addEventListener('click', () => {
+        window.clicked = (window.clicked ?? 0) + 1;
+      }, false);
+
+      close.addEventListener('click', () => {
+        const closeInterstitial = () => {
+          interstitial.classList.remove('visible');
+          target.classList.remove('hidden');
+          target.classList.remove('removed');
+        };
+
+        if (interstitial.classList.contains('timeout'))
+          setTimeout(closeInterstitial, 3000);
+        else
+          closeInterstitial();
+      });
+
+      let timesToShow = 0;
+      function setupAnnoyingInterstitial(event, times, capture) {
+        timesToShow = times;
+        const listener = () => {
+          timesToShow--;
+          interstitial.classList.add('visible');
+          interstitial.getBoundingClientRect();
+          if (!timesToShow && event !== 'none')
+            target.removeEventListener(event, listener, capture === 'capture');
+        };
+        if (event === 'hide' || event === 'timeout') {
+          target.classList.add('hidden');
+          listener();
+          if (event === 'timeout')
+            interstitial.classList.add('timeout');
+        } else if (event === 'remove') {
+          target.classList.add('removed');
+          listener();
+        } else if (event === 'none') {
+          listener();
+        } else {
+          target.addEventListener(event, listener, capture === 'capture');
+        }
+      }
+    </script>
+  </body>
+</html>
diff --git a/tests/assets/networkidle.html b/tests/assets/networkidle.html
new file mode 100644
index 000000000..ab10c9796
--- /dev/null
+++ b/tests/assets/networkidle.html
@@ -0,0 +1 @@
+<script src='networkidle.js'></script>
diff --git a/tests/assets/networkidle.js b/tests/assets/networkidle.js
new file mode 100644
index 000000000..9d8998458
--- /dev/null
+++ b/tests/assets/networkidle.js
@@ -0,0 +1,12 @@
+async function main() {
+  window.ws = new WebSocket('ws://localhost:' + window.location.port + '/ws');
+  window.ws.addEventListener('message', message => {});
+
+  fetch('fetch-request-a.js');
+  window.top.fetchSecond = () => {
+    // Do not return the promise here.
+    fetch('fetch-request-b.js');
+  };
+}
+
+main();
diff --git a/tests/async/conftest.py b/tests/async/conftest.py
index 50d3abf03..8b5e40870 100644
--- a/tests/async/conftest.py
+++ b/tests/async/conftest.py
@@ -1,6 +1,6 @@
 # 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
 #
@@ -12,62 +12,202 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any, AsyncGenerator, Awaitable, Callable, Dict, Generator
+
 import pytest
 
-from playwright.async_api import async_playwright
+from playwright._impl._driver import compute_driver_executable
+from playwright.async_api import (
+    Browser,
+    BrowserContext,
+    BrowserType,
+    FrameLocator,
+    Locator,
+    Page,
+    Playwright,
+    Selectors,
+    async_playwright,
+)
+from tests.server import HTTPServer
+
+from .utils import Utils
+from .utils import utils as utils_object
 
 
-# Will mark all the tests as async
-def pytest_collection_modifyitems(items):
-    for item in items:
-        item.add_marker(pytest.mark.asyncio)
+@pytest.fixture
+def utils() -> Generator[Utils, None, None]:
+    yield utils_object
 
 
 @pytest.fixture(scope="session")
-async def playwright():
+async def playwright() -> AsyncGenerator[Playwright, None]:
     async with async_playwright() as playwright_object:
         yield playwright_object
 
 
 @pytest.fixture(scope="session")
-def browser_type(playwright, browser_name: str):
+def browser_type(playwright: Playwright, browser_name: str) -> BrowserType:
     if browser_name == "chromium":
         return playwright.chromium
     if browser_name == "firefox":
         return playwright.firefox
     if browser_name == "webkit":
         return playwright.webkit
+    raise Exception(f"Invalid browser_name: {browser_name}")
 
 
 @pytest.fixture(scope="session")
-async def browser_factory(launch_arguments, browser_type):
-    async def launch(**kwargs):
-        return await browser_type.launch(**launch_arguments, **kwargs)
+async def browser_factory(
+    launch_arguments: Dict, browser_type: BrowserType
+) -> AsyncGenerator[Callable[..., Awaitable[Browser]], None]:
+    browsers = []
+
+    async def launch(**kwargs: Any) -> Browser:
+        browser = await browser_type.launch(**launch_arguments, **kwargs)
+        browsers.append(browser)
+        return browser
 
-    return launch
+    yield launch
+    for browser in browsers:
+        await browser.close()
 
 
 @pytest.fixture(scope="session")
-async def browser(browser_factory):
+async def browser(
+    browser_factory: "Callable[..., asyncio.Future[Browser]]",
+) -> AsyncGenerator[Browser, None]:
     browser = await browser_factory()
     yield browser
     await browser.close()
 
 
+@pytest.fixture(scope="session")
+def browser_version(browser: Browser) -> str:
+    return browser.version
+
+
+@pytest.fixture
+async def context_factory(
+    browser: Browser,
+) -> AsyncGenerator["Callable[..., Awaitable[BrowserContext]]", None]:
+    contexts = []
+
+    async def launch(**kwargs: Any) -> BrowserContext:
+        context = await browser.new_context(**kwargs)
+        contexts.append(context)
+        return context
+
+    yield launch
+    for context in contexts:
+        await context.close()
+
+
+@pytest.fixture(scope="session")
+def default_same_site_cookie_value(browser_name: str, is_linux: bool) -> str:
+    if browser_name == "chromium":
+        return "Lax"
+    if browser_name == "firefox":
+        return "None"
+    if browser_name == "webkit" and is_linux:
+        return "Lax"
+    if browser_name == "webkit" and not is_linux:
+        return "None"
+    raise Exception(f"Invalid browser_name: {browser_name}")
+
+
 @pytest.fixture
-async def context(browser):
-    context = await browser.new_context()
+async def context(
+    context_factory: "Callable[..., asyncio.Future[BrowserContext]]",
+) -> AsyncGenerator[BrowserContext, None]:
+    context = await context_factory()
     yield context
     await context.close()
 
 
 @pytest.fixture
-async def page(context):
+async def page(context: BrowserContext) -> AsyncGenerator[Page, None]:
     page = await context.new_page()
     yield page
     await page.close()
 
 
 @pytest.fixture(scope="session")
-def selectors(playwright):
+def selectors(playwright: Playwright) -> Selectors:
     return playwright.selectors
+
+
+class TraceViewerPage:
+    def __init__(self, page: Page):
+        self.page = page
+
+    @property
+    def actions_tree(self) -> Locator:
+        return self.page.get_by_test_id("actions-tree")
+
+    @property
+    def action_titles(self) -> Locator:
+        return self.page.locator(".action-title")
+
+    @property
+    def stack_frames(self) -> Locator:
+        return self.page.get_by_role("listbox", name="Stack trace").get_by_role(
+            "option"
+        )
+
+    async def select_action(self, title: str, ordinal: int = 0) -> None:
+        await self.page.locator(".action-title", has_text=title).nth(ordinal).click()
+
+    async def select_snapshot(self, name: str) -> None:
+        await self.page.click(
+            f'.snapshot-tab .tabbed-pane-tab-label:has-text("{name}")'
+        )
+
+    async def snapshot_frame(
+        self, action_name: str, ordinal: int = 0, has_subframe: bool = False
+    ) -> FrameLocator:
+        await self.select_action(action_name, ordinal)
+        expected_frames = 4 if has_subframe else 3
+        while len(self.page.frames) < expected_frames:
+            await self.page.wait_for_event("frameattached")
+        return self.page.frame_locator("iframe.snapshot-visible[name=snapshot]")
+
+    async def show_source_tab(self) -> None:
+        await self.page.click("text='Source'")
+
+    async def expand_action(self, title: str, ordinal: int = 0) -> None:
+        await self.actions_tree.locator(".tree-view-entry", has_text=title).nth(
+            ordinal
+        ).locator(".codicon-chevron-right").click()
+
+
+@pytest.fixture
+async def show_trace_viewer(browser: Browser) -> AsyncGenerator[Callable, None]:
+    """Fixture that provides a function to show trace viewer for a trace file."""
+
+    @asynccontextmanager
+    async def _show_trace_viewer(
+        trace_path: Path,
+    ) -> AsyncGenerator[TraceViewerPage, None]:
+        trace_viewer_path = (
+            Path(compute_driver_executable()[0]) / "../package/lib/vite/traceViewer"
+        ).resolve()
+
+        server = HTTPServer()
+        server.start(trace_viewer_path)
+        server.set_route("/trace.zip", lambda request: request.serve_file(trace_path))
+
+        page = await browser.new_page()
+
+        try:
+            await page.goto(
+                f"{server.PREFIX}/index.html?trace={server.PREFIX}/trace.zip"
+            )
+            yield TraceViewerPage(page)
+        finally:
+            await page.close()
+            server.stop()
+
+    yield _show_trace_viewer
diff --git a/tests/async/test_accessibility.py b/tests/async/test_accessibility.py
deleted file mode 100644
index c93040e29..000000000
--- a/tests/async/test_accessibility.py
+++ /dev/null
@@ -1,419 +0,0 @@
-# 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 pytest
-
-
-async def test_accessibility_should_work(page, is_firefox, is_chromium):
-    await page.set_content(
-        """<head>
-      <title>Accessibility Test</title>
-    </head>
-    <body>
-      <h1>Inputs</h1>
-      <input placeholder="Empty input" autofocus />
-      <input placeholder="readonly input" readonly />
-      <input placeholder="disabled input" disabled />
-      <input aria-label="Input with whitespace" value="  " />
-      <input value="value only" />
-      <input aria-placeholder="placeholder" value="and a value" />
-      <div aria-hidden="true" id="desc">This is a description!</div>
-      <input aria-placeholder="placeholder" value="and a value" aria-describedby="desc" />
-    </body>"""
-    )
-    # autofocus happens after a delay in chrome these days
-    await page.wait_for_function("document.activeElement.hasAttribute('autofocus')")
-
-    if is_firefox:
-        golden = {
-            "role": "document",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {
-                    "role": "textbox",
-                    "name": "",
-                    "value": "and a value",
-                },  # firefox doesn't use aria-placeholder for the name
-                {
-                    "role": "textbox",
-                    "name": "",
-                    "value": "and a value",
-                    "description": "This is a description!",
-                },  # and here
-            ],
-        }
-    elif is_chromium:
-        golden = {
-            "role": "WebArea",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {"role": "textbox", "name": "placeholder", "value": "and a value"},
-                {
-                    "role": "textbox",
-                    "name": "placeholder",
-                    "value": "and a value",
-                    "description": "This is a description!",
-                },
-            ],
-        }
-    else:
-        golden = {
-            "role": "WebArea",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {"role": "textbox", "name": "placeholder", "value": "and a value"},
-                {
-                    "role": "textbox",
-                    "name": "This is a description!",
-                    "value": "and a value",
-                },  # webkit uses the description over placeholder for the name
-            ],
-        }
-    assert await page.accessibility.snapshot() == golden
-
-
-async def test_accessibility_should_work_with_regular_text(page, is_firefox):
-    await page.set_content("<div>Hello World</div>")
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0] == {
-        "role": "text leaf" if is_firefox else "text",
-        "name": "Hello World",
-    }
-
-
-async def test_accessibility_roledescription(page):
-    await page.set_content('<div tabIndex=-1 aria-roledescription="foo">Hi</div>')
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0]["roledescription"] == "foo"
-
-
-async def test_accessibility_orientation(page):
-    await page.set_content(
-        '<a href="" role="slider" aria-orientation="vertical">11</a>'
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0]["orientation"] == "vertical"
-
-
-async def test_accessibility_autocomplete(page):
-    await page.set_content('<div role="textbox" aria-autocomplete="list">hi</div>')
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0]["autocomplete"] == "list"
-
-
-async def test_accessibility_multiselectable(page):
-    await page.set_content(
-        '<div role="grid" tabIndex=-1 aria-multiselectable=true>hey</div>'
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0]["multiselectable"]
-
-
-async def test_accessibility_keyshortcuts(page):
-    await page.set_content(
-        '<div role="grid" tabIndex=-1 aria-keyshortcuts="foo">hey</div>'
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0]["keyshortcuts"] == "foo"
-
-
-async def test_accessibility_filtering_children_of_leaf_nodes_should_not_report_text_nodes_inside_controls(
-    page, is_firefox
-):
-    await page.set_content(
-        """
-    <div role="tablist">
-    <div role="tab" aria-selected="true"><b>Tab1</b></div>
-    <div role="tab">Tab2</div>
-    </div>"""
-    )
-    golden = {
-        "role": "document" if is_firefox else "WebArea",
-        "name": "",
-        "children": [
-            {"role": "tab", "name": "Tab1", "selected": True},
-            {"role": "tab", "name": "Tab2"},
-        ],
-    }
-    assert await page.accessibility.snapshot() == golden
-
-
-# WebKit rich text accessibility is iffy
-@pytest.mark.skip_browser("webkit")
-async def test_accessibility_filtering_children_of_leaf_nodes_rich_text_editable_fields_should_have_children(
-    page, is_firefox
-):
-    await page.set_content(
-        """
-    <div contenteditable="true">
-    Edit this image: <img src="fakeimage.png" alt="my fake image">
-    </div>"""
-    )
-    golden = (
-        {
-            "role": "section",
-            "name": "",
-            "children": [
-                {"role": "text leaf", "name": "Edit this image: "},
-                {"role": "text", "name": "my fake image"},
-            ],
-        }
-        if is_firefox
-        else {
-            "role": "generic",
-            "name": "",
-            "value": "Edit this image: ",
-            "children": [
-                {"role": "text", "name": "Edit this image:"},
-                {"role": "img", "name": "my fake image"},
-            ],
-        }
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0] == golden
-
-
-# WebKit rich text accessibility is iffy
-@pytest.mark.skip_browser("webkit")
-async def test_accessibility_filtering_children_of_leaf_nodes_rich_text_editable_fields_with_role_should_have_children(
-    page,
-    is_firefox,
-):
-    await page.set_content(
-        """
-    <div contenteditable="true" role='textbox'>
-    Edit this image: <img src="fakeimage.png" alt="my fake image">
-    </div>"""
-    )
-    if is_firefox:
-        golden = {
-            "role": "textbox",
-            "name": "",
-            "value": "Edit this image: my fake image",
-            "children": [{"role": "text", "name": "my fake image"}],
-        }
-    else:
-        golden = {
-            "role": "textbox",
-            "name": "",
-            "value": "Edit this image: ",
-            "children": [
-                {"role": "text", "name": "Edit this image:"},
-                {"role": "img", "name": "my fake image"},
-            ],
-        }
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0] == golden
-
-
-# Firefox does not support contenteditable="plaintext-only".
-# WebKit rich text accessibility is iffy
-@pytest.mark.only_browser("chromium")
-async def test_accessibility_plain_text_field_with_role_should_not_have_children(page):
-    await page.set_content(
-        """
-    <div contenteditable="plaintext-only" role='textbox'>Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0] == {
-        "role": "textbox",
-        "name": "",
-        "value": "Edit this image:",
-    }
-
-
-@pytest.mark.only_browser("chromium")
-async def test_accessibility_plain_text_field_without_role_should_not_have_content(
-    page,
-):
-    await page.set_content(
-        """
-    <div contenteditable="plaintext-only">Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0] == {"role": "generic", "name": ""}
-
-
-@pytest.mark.only_browser("chromium")
-async def test_accessibility_plain_text_field_with_tabindex_and_without_role_should_not_have_content(
-    page,
-):
-    await page.set_content(
-        """
-    <div contenteditable="plaintext-only" tabIndex=0>Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0] == {"role": "generic", "name": ""}
-
-
-async def test_accessibility_non_editable_textbox_with_role_and_tabIndex_and_label_should_not_have_children(
-    page, is_chromium, is_firefox
-):
-    await page.set_content(
-        """
-      <div role="textbox" tabIndex=0 aria-checked="true" aria-label="my favorite textbox">
-        this is the inner content
-        <img alt="yo" src="fakeimg.png">
-      </div>"""
-    )
-    if is_firefox:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content yo",
-        }
-    elif is_chromium:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content ",
-        }
-    else:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content  ",
-        }
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0] == golden
-
-
-async def test_accessibility_checkbox_with_and_tabIndex_and_label_should_not_have_children(
-    page,
-):
-    await page.set_content(
-        """
-    <div role="checkbox" tabIndex=0 aria-checked="true" aria-label="my favorite checkbox">
-    this is the inner content
-    <img alt="yo" src="fakeimg.png">
-    </div>"""
-    )
-    golden = {"role": "checkbox", "name": "my favorite checkbox", "checked": True}
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0] == golden
-
-
-async def test_accessibility_checkbox_without_label_should_not_have_children(
-    page, is_firefox
-):
-    await page.set_content(
-        """
-      <div role="checkbox" aria-checked="true">
-        this is the inner content
-        <img alt="yo" src="fakeimg.png">
-    </div>"""
-    )
-    golden = {
-        "role": "checkbox",
-        "name": "this is the inner content yo",
-        "checked": True,
-    }
-    snapshot = await page.accessibility.snapshot()
-    assert snapshot["children"][0] == golden
-
-
-async def test_accessibility_should_work_a_button(page):
-    await page.set_content("<button>My Button</button>")
-
-    button = await page.query_selector("button")
-    assert await page.accessibility.snapshot(root=button) == {
-        "role": "button",
-        "name": "My Button",
-    }
-
-
-async def test_accessibility_should_work_an_input(page):
-    await page.set_content('<input title="My Input" value="My Value">')
-
-    input = await page.query_selector("input")
-    assert await page.accessibility.snapshot(root=input) == {
-        "role": "textbox",
-        "name": "My Input",
-        "value": "My Value",
-    }
-
-
-async def test_accessibility_should_work_on_a_menu(page, is_webkit):
-    await page.set_content(
-        """
-        <div role="menu" title="My Menu">
-        <div role="menuitem">First Item</div>
-        <div role="menuitem">Second Item</div>
-        <div role="menuitem">Third Item</div>
-        </div>
-    """
-    )
-
-    menu = await page.query_selector('div[role="menu"]')
-    golden = {
-        "role": "menu",
-        "name": "My Menu",
-        "children": [
-            {"role": "menuitem", "name": "First Item"},
-            {"role": "menuitem", "name": "Second Item"},
-            {"role": "menuitem", "name": "Third Item"},
-        ],
-    }
-    if is_webkit:
-        golden["orientation"] = "vertical"
-    assert await page.accessibility.snapshot(root=menu) == golden
-
-
-async def test_accessibility_should_return_null_when_the_element_is_no_longer_in_DOM(
-    page,
-):
-    await page.set_content("<button>My Button</button>")
-    button = await page.query_selector("button")
-    await page.eval_on_selector("button", "button => button.remove()")
-    assert await page.accessibility.snapshot(root=button) is None
-
-
-async def test_accessibility_should_show_uninteresting_nodes(page):
-    await page.set_content(
-        """
-        <div id="root" role="textbox">
-        <div>
-            hello
-            <div>
-            world
-            </div>
-        </div>
-        </div>
-    """
-    )
-
-    root = await page.query_selector("#root")
-    snapshot = await page.accessibility.snapshot(root=root, interesting_only=False)
-    assert snapshot["role"] == "textbox"
-    assert "hello" in snapshot["value"]
-    assert "world" in snapshot["value"]
-    assert snapshot["children"]
diff --git a/tests/async/test_add_init_script.py b/tests/async/test_add_init_script.py
index 83d9f14bb..7dbae8aba 100644
--- a/tests/async/test_add_init_script.py
+++ b/tests/async/test_add_init_script.py
@@ -1,6 +1,6 @@
 # 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
 #
@@ -12,37 +12,45 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from playwright.async_api import Error
+from pathlib import Path
+from typing import Optional
 
+from playwright.async_api import BrowserContext, Error, Page
 
-async def test_add_init_script_evaluate_before_anything_else_on_the_page(page):
+
+async def test_add_init_script_evaluate_before_anything_else_on_the_page(
+    page: Page,
+) -> None:
     await page.add_init_script("window.injected = 123")
     await page.goto("data:text/html,<script>window.result = window.injected</script>")
     assert await page.evaluate("window.result") == 123
 
 
-async def test_add_init_script_work_with_a_path(page, assetdir):
+async def test_add_init_script_work_with_a_path(page: Page, assetdir: Path) -> None:
     await page.add_init_script(path=assetdir / "injectedfile.js")
     await page.goto("data:text/html,<script>window.result = window.injected</script>")
     assert await page.evaluate("window.result") == 123
 
 
-async def test_add_init_script_work_with_content(page):
+async def test_add_init_script_work_with_content(page: Page) -> None:
     await page.add_init_script("window.injected = 123")
     await page.goto("data:text/html,<script>window.result = window.injected</script>")
     assert await page.evaluate("window.result") == 123
 
 
-async def test_add_init_script_throw_without_path_and_content(page):
-    error = None
+async def test_add_init_script_throw_without_path_and_content(page: Page) -> None:
+    error: Optional[Error] = None
     try:
-        await page.add_init_script({"foo": "bar"})
+        await page.add_init_script({"foo": "bar"})  # type: ignore
     except Error as e:
         error = e
-    assert error.message == "Either path or source parameter must be specified"
+    assert error
+    assert error.message == "Either path or script parameter must be specified"
 
 
-async def test_add_init_script_work_with_browser_context_scripts(page, context):
+async def test_add_init_script_work_with_browser_context_scripts(
+    page: Page, context: BrowserContext
+) -> None:
     await context.add_init_script("window.temp = 123")
     page = await context.new_page()
     await page.add_init_script("window.injected = window.temp")
@@ -51,8 +59,8 @@ async def test_add_init_script_work_with_browser_context_scripts(page, context):
 
 
 async def test_add_init_script_work_with_browser_context_scripts_with_a_path(
-    page, context, assetdir
-):
+    page: Page, context: BrowserContext, assetdir: Path
+) -> None:
     await context.add_init_script(path=assetdir / "injectedfile.js")
     page = await context.new_page()
     await page.goto("data:text/html,<script>window.result = window.injected</script>")
@@ -60,17 +68,34 @@ async def test_add_init_script_work_with_browser_context_scripts_with_a_path(
 
 
 async def test_add_init_script_work_with_browser_context_scripts_for_already_created_pages(
-    page, context
-):
+    page: Page, context: BrowserContext
+) -> None:
     await context.add_init_script("window.temp = 123")
     await page.add_init_script("window.injected = window.temp")
     await page.goto("data:text/html,<script>window.result = window.injected</script>")
     assert await page.evaluate("window.result") == 123
 
 
-async def test_add_init_script_support_multiple_scripts(page):
+async def test_add_init_script_support_multiple_scripts(page: Page) -> None:
     await page.add_init_script("window.script1 = 1")
     await page.add_init_script("window.script2 = 2")
     await page.goto("data:text/html,<script>window.result = window.injected</script>")
     assert await page.evaluate("window.script1") == 1
     assert await page.evaluate("window.script2") == 2
+
+
+async def test_should_work_with_trailing_comments(page: Page) -> None:
+    await page.add_init_script("// comment")
+    await page.add_init_script("window.secret = 42;")
+    await page.goto("data:text/html,<html></html>")
+    assert await page.evaluate("secret") == 42
+
+
+async def test_add_init_script_returns_disposable(page: Page) -> None:
+    async with await page.add_init_script("window.injected = 123"):
+        await page.goto(
+            "data:text/html,<script>window.result = window.injected</script>"
+        )
+        assert await page.evaluate("window.result") == 123
+    await page.goto("data:text/html,<script>window.result = window.injected</script>")
+    assert await page.evaluate("window.result") is None
diff --git a/tests/async/test_assertions.py b/tests/async/test_assertions.py
new file mode 100644
index 000000000..3fd403ac1
--- /dev/null
+++ b/tests/async/test_assertions.py
@@ -0,0 +1,1201 @@
+# 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 asyncio
+import datetime
+import re
+
+import pytest
+
+from playwright.async_api import Browser, Error, Page, expect
+from tests.server import Server
+
+
+async def test_assertions_page_to_have_title(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<title>new title</title>")
+    await expect(page).to_have_title("new title")
+    await expect(page).to_have_title(re.compile("new title"))
+    with pytest.raises(AssertionError):
+        await expect(page).to_have_title("not the current title", timeout=750)
+    with pytest.raises(AssertionError):
+        await expect(page).to_have_title(
+            re.compile("not the current title"), timeout=750
+        )
+    with pytest.raises(AssertionError):
+        await expect(page).not_to_have_title(re.compile("new title"), timeout=750)
+    with pytest.raises(AssertionError):
+        await expect(page).not_to_have_title("new title", timeout=750)
+    await expect(page).not_to_have_title("great title", timeout=750)
+    await page.evaluate(
+        """
+        setTimeout(() => {
+            document.title = 'great title';
+        }, 2000);
+    """
+    )
+    await expect(page).to_have_title("great title")
+    await expect(page).to_have_title(re.compile("great title"))
+
+
+async def test_assertions_page_to_have_url(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await expect(page).to_have_url(server.EMPTY_PAGE)
+    await expect(page).to_have_url(re.compile(r".*/empty\.html"))
+    with pytest.raises(AssertionError):
+        await expect(page).to_have_url("nooooo", timeout=750)
+    with pytest.raises(AssertionError):
+        await expect(page).to_have_url(re.compile("not-the-url"), timeout=750)
+    await page.evaluate(
+        """
+        setTimeout(() => {
+            window.location = window.location.origin + '/grid.html';
+        }, 2000);
+    """
+    )
+    await expect(page).to_have_url(server.PREFIX + "/grid.html")
+    await expect(page).not_to_have_url(server.EMPTY_PAGE, timeout=750)
+    with pytest.raises(AssertionError):
+        await expect(page).not_to_have_url(re.compile(r".*/grid\.html"), timeout=750)
+    with pytest.raises(AssertionError):
+        await expect(page).not_to_have_url(server.PREFIX + "/grid.html", timeout=750)
+    await expect(page).to_have_url(re.compile(r".*/grid\.html"))
+    await expect(page).not_to_have_url("**/empty.html", timeout=750)
+
+
+async def test_assertions_page_to_have_url_with_base_url(
+    browser: Browser, server: Server
+) -> None:
+    page = await browser.new_page(base_url=server.PREFIX)
+    await page.goto("/empty.html")
+    await expect(page).to_have_url("/empty.html")
+    await expect(page).to_have_url(re.compile(r".*/empty\.html"))
+    await page.close()
+
+
+async def test_assertions_page_to_have_url_support_ignore_case(page: Page) -> None:
+    await page.goto("data:text/html,<div>A</div>")
+    await expect(page).to_have_url("DATA:teXT/HTml,<div>a</div>", ignore_case=True)
+
+
+async def test_assertions_locator_to_contain_text(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div id=foobar>kek</div>")
+    await expect(page.locator("div#foobar")).to_contain_text("kek")
+    await expect(page.locator("div#foobar")).not_to_contain_text("bar", timeout=100)
+    with pytest.raises(AssertionError):
+        await expect(page.locator("div#foobar")).to_contain_text("bar", timeout=100)
+
+    await page.set_content("<div>Text \n1</div><div>Text2</div><div>Text3</div>")
+    await expect(page.locator("div")).to_contain_text(["ext     1", re.compile("ext3")])
+
+
+async def test_assertions_locator_to_contain_text_should_throw_if_arg_is_unsupported_type(
+    page: Page,
+) -> None:
+    with pytest.raises(Error, match="value must be a string or regular expression"):
+        await expect(page.locator("div")).to_contain_text(1)  # type: ignore
+
+
+async def test_assertions_locator_to_have_attribute(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div id=foobar>kek</div>")
+    await expect(page.locator("div#foobar")).to_have_attribute("id", "foobar")
+    await expect(page.locator("div#foobar")).to_have_attribute(
+        "id", re.compile("foobar")
+    )
+    await expect(page.locator("div#foobar")).not_to_have_attribute(
+        "id", "kek", timeout=100
+    )
+    with pytest.raises(AssertionError):
+        await expect(page.locator("div#foobar")).to_have_attribute(
+            "id", "koko", timeout=100
+        )
+
+
+async def test_assertions_locator_to_have_attribute_ignore_case(
+    page: Page, server: Page
+) -> None:
+    await page.set_content("<div id=NoDe>Text content</div>")
+    locator = page.locator("#NoDe")
+    await expect(locator).to_have_attribute("id", "node", ignore_case=True)
+    await expect(locator).not_to_have_attribute("id", "node")
+
+
+async def test_assertions_locator_to_have_class(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div class=foobar>kek</div>")
+    await expect(page.locator("div.foobar")).to_have_class("foobar")
+    await expect(page.locator("div.foobar")).to_have_class(["foobar"])
+    await expect(page.locator("div.foobar")).to_have_class(re.compile("foobar"))
+    await expect(page.locator("div.foobar")).to_have_class([re.compile("foobar")])
+    await expect(page.locator("div.foobar")).not_to_have_class("kekstar", timeout=100)
+    with pytest.raises(AssertionError):
+        await expect(page.locator("div.foobar")).to_have_class("oh-no", timeout=100)
+
+
+async def test_assertions_locator_to_contain_class(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div class='foo bar baz'></div>")
+    locator = page.locator("div")
+    await expect(locator).to_contain_class("")
+    await expect(locator).to_contain_class("bar")
+    await expect(locator).to_contain_class("baz bar")
+    await expect(locator).to_contain_class("  bar   foo ")
+    await expect(locator).not_to_contain_class(
+        "  baz   not-matching "
+    )  # Strip whitespace and match individual classes
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(locator).to_contain_class("does-not-exist", timeout=100)
+
+    assert excinfo.match("Locator expected to contain class 'does-not-exist'")
+    assert excinfo.match("Actual value: foo bar baz")
+    assert excinfo.match('Expect "to_contain_class" with timeout 100ms')
+
+    await page.set_content(
+        '<div class="foo"></div><div class="hello bar"></div><div class="baz"></div>'
+    )
+    await expect(locator).to_contain_class(["foo", "hello", "baz"])
+    await expect(locator).not_to_contain_class(["not-there", "hello", "baz"])
+    await expect(locator).not_to_contain_class(["foo", "hello"])
+
+
+async def test_assertions_locator_to_have_count(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div class=foobar>kek</div><div class=foobar>kek</div>")
+    await expect(page.locator("div.foobar")).to_have_count(2)
+    await expect(page.locator("div.foobar")).not_to_have_count(42, timeout=100)
+    with pytest.raises(AssertionError):
+        await expect(page.locator("div.foobar")).to_have_count(42, timeout=100)
+
+
+async def test_assertions_locator_to_have_css(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content(
+        "<div class=foobar style='color: rgb(234, 74, 90);'>kek</div>"
+    )
+    await expect(page.locator("div.foobar")).to_have_css("color", "rgb(234, 74, 90)")
+    await expect(page.locator("div.foobar")).not_to_have_css(
+        "color", "rgb(42, 42, 42)", timeout=100
+    )
+    with pytest.raises(AssertionError):
+        await expect(page.locator("div.foobar")).to_have_css(
+            "color", "rgb(42, 42, 42)", timeout=100
+        )
+
+
+async def test_assertions_locator_to_have_id(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div class=foobar id=kek>kek</div>")
+    await expect(page.locator("div.foobar")).to_have_id("kek")
+    await expect(page.locator("div.foobar")).not_to_have_id("top", timeout=100)
+    with pytest.raises(AssertionError):
+        await expect(page.locator("div.foobar")).to_have_id("top", timeout=100)
+
+
+async def test_assertions_locator_to_have_js_property(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div></div>")
+    await page.eval_on_selector(
+        "div", "e => e.foo = { a: 1, b: 'string', c: new Date(1627503992000) }"
+    )
+    await expect(page.locator("div")).to_have_js_property(
+        "foo",
+        {
+            "a": 1,
+            "b": "string",
+            "c": datetime.datetime.fromtimestamp(1627503992000 / 1000),
+        },
+    )
+
+
+async def test_to_have_js_property_pass_string(page: Page) -> None:
+    await page.set_content("<div></div>")
+    await page.eval_on_selector("div", "e => e.foo = 'string'")
+    locator = page.locator("div")
+    await expect(locator).to_have_js_property("foo", "string")
+
+
+async def test_to_have_js_property_fail_string(page: Page) -> None:
+    await page.set_content("<div></div>")
+    await page.eval_on_selector("div", "e => e.foo = 'string'")
+    locator = page.locator("div")
+    with pytest.raises(AssertionError):
+        await expect(locator).to_have_js_property("foo", "error", timeout=500)
+
+
+async def test_to_have_js_property_pass_number(page: Page) -> None:
+    await page.set_content("<div></div>")
+    await page.eval_on_selector("div", "e => e.foo = 2021")
+    locator = page.locator("div")
+    await expect(locator).to_have_js_property("foo", 2021)
+
+
+async def test_to_have_js_property_fail_number(page: Page) -> None:
+    await page.set_content("<div></div>")
+    await page.eval_on_selector("div", "e => e.foo = 2021")
+    locator = page.locator("div")
+    with pytest.raises(AssertionError):
+        await expect(locator).to_have_js_property("foo", 1, timeout=500)
+
+
+async def test_to_have_js_property_pass_boolean(page: Page) -> None:
+    await page.set_content("<div></div>")
+    await page.eval_on_selector("div", "e => e.foo = true")
+    locator = page.locator("div")
+    await expect(locator).to_have_js_property("foo", True)
+
+
+async def test_to_have_js_property_fail_boolean(page: Page) -> None:
+    await page.set_content("<div></div>")
+    await page.eval_on_selector("div", "e => e.foo = false")
+    locator = page.locator("div")
+    with pytest.raises(AssertionError):
+        await expect(locator).to_have_js_property("foo", True, timeout=500)
+
+
+async def test_to_have_js_property_pass_boolean_2(page: Page) -> None:
+    await page.set_content("<div></div>")
+    await page.eval_on_selector("div", "e => e.foo = false")
+    locator = page.locator("div")
+    await expect(locator).to_have_js_property("foo", False)
+
+
+async def test_to_have_js_property_fail_boolean_2(page: Page) -> None:
+    await page.set_content("<div></div>")
+    await page.eval_on_selector("div", "e => e.foo = false")
+    locator = page.locator("div")
+    with pytest.raises(AssertionError):
+        await expect(locator).to_have_js_property("foo", True, timeout=500)
+
+
+async def test_to_have_js_property_pass_null(page: Page) -> None:
+    await page.set_content("<div></div>")
+    await page.eval_on_selector("div", "e => e.foo = null")
+    locator = page.locator("div")
+    await expect(locator).to_have_js_property("foo", None)
+
+
+async def test_assertions_locator_to_have_text(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div id=foobar>kek</div>")
+    await expect(page.locator("div#foobar")).to_have_text("kek")
+    await expect(page.locator("div#foobar")).not_to_have_text("top", timeout=100)
+
+    await page.set_content("<div>Text    \n1</div><div>Text   2a</div>")
+    # Should only normalize whitespace in the first item.
+    await expect(page.locator("div")).to_have_text(
+        ["Text  1", re.compile(r"Text   \d+a")]
+    )
+    # Should work with a tuple
+    await expect(page.locator("div")).to_have_text(
+        ("Text  1", re.compile(r"Text   \d+a"))
+    )
+
+
+@pytest.mark.parametrize(
+    "method",
+    ["to_have_text", "to_contain_text"],
+)
+async def test_ignore_case(page: Page, server: Server, method: str) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div id=target>apple BANANA</div><div>orange</div>")
+    await getattr(expect(page.locator("div#target")), method)("apple BANANA")
+    await getattr(expect(page.locator("div#target")), method)(
+        "apple banana", ignore_case=True
+    )
+    # defaults false
+    with pytest.raises(AssertionError) as excinfo:
+        await getattr(expect(page.locator("div#target")), method)(
+            "apple banana", timeout=300
+        )
+    expected_error_msg = method.replace("_", " ")
+    assert expected_error_msg in str(excinfo.value)
+
+    # Array Variants
+    await getattr(expect(page.locator("div")), method)(["apple BANANA", "orange"])
+    await getattr(expect(page.locator("div")), method)(
+        ["apple banana", "ORANGE"], ignore_case=True
+    )
+    # defaults false
+    with pytest.raises(AssertionError) as excinfo:
+        await getattr(expect(page.locator("div")), method)(
+            ["apple banana", "ORANGE"], timeout=300
+        )
+    assert expected_error_msg in str(excinfo.value)
+
+    # not variant
+    await getattr(expect(page.locator("div#target")), f"not_{method}")("apple banana")
+    with pytest.raises(AssertionError) as excinfo:
+        await getattr(expect(page.locator("div#target")), f"not_{method}")(
+            "apple banana", ignore_case=True, timeout=300
+        )
+    assert f"not {expected_error_msg}" in str(excinfo)
+
+
+@pytest.mark.parametrize(
+    "method",
+    ["to_have_text", "to_contain_text"],
+)
+async def test_ignore_case_regex(page: Page, server: Server, method: str) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div id=target>apple BANANA</div><div>orange</div>")
+    await getattr(expect(page.locator("div#target")), method)(
+        re.compile("apple BANANA")
+    )
+    await getattr(expect(page.locator("div#target")), method)(
+        re.compile("apple banana"), ignore_case=True
+    )
+    # defaults to regex flag
+    with pytest.raises(AssertionError) as excinfo:
+        await getattr(expect(page.locator("div#target")), method)(
+            re.compile("apple banana"), timeout=300
+        )
+    expected_error_msg = method.replace("_", " ")
+    assert expected_error_msg in str(excinfo.value)
+    # overrides regex flag
+    with pytest.raises(AssertionError) as excinfo:
+        await getattr(expect(page.locator("div#target")), method)(
+            re.compile("apple banana", re.IGNORECASE), ignore_case=False, timeout=300
+        )
+    assert expected_error_msg in str(excinfo.value)
+
+    # Array Variants
+    await getattr(expect(page.locator("div")), method)(
+        [re.compile("apple BANANA"), re.compile("orange")]
+    )
+    await getattr(expect(page.locator("div")), method)(
+        [re.compile("apple banana"), re.compile("ORANGE")], ignore_case=True
+    )
+    # defaults regex flag
+    with pytest.raises(AssertionError) as excinfo:
+        await getattr(expect(page.locator("div")), method)(
+            [re.compile("apple banana"), re.compile("ORANGE")], timeout=300
+        )
+    assert expected_error_msg in str(excinfo.value)
+    # overrides regex flag
+    with pytest.raises(AssertionError) as excinfo:
+        await getattr(expect(page.locator("div")), method)(
+            [
+                re.compile("apple banana", re.IGNORECASE),
+                re.compile("ORANGE", re.IGNORECASE),
+            ],
+            ignore_case=False,
+            timeout=300,
+        )
+    assert expected_error_msg in str(excinfo.value)
+
+    # not variant
+    await getattr(expect(page.locator("div#target")), f"not_{method}")(
+        re.compile("apple banana")
+    )
+    with pytest.raises(AssertionError) as excinfo:
+        await getattr(expect(page.locator("div#target")), f"not_{method}")(
+            re.compile("apple banana"), ignore_case=True, timeout=300
+        )
+    assert f"not {expected_error_msg}" in str(excinfo)
+
+
+async def test_assertions_locator_to_have_value(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<input type=text id=foo>")
+    my_input = page.locator("#foo")
+    await expect(my_input).to_have_value("")
+    await expect(my_input).not_to_have_value("bar", timeout=100)
+    await my_input.fill("kektus")
+    await expect(my_input).to_have_value("kektus")
+
+
+async def test_to_have_values_works_with_text(page: Page, server: Server) -> None:
+    await page.set_content(
+        """
+        <select multiple>
+            <option value="R">Red</option>
+            <option value="G">Green</option>
+            <option value="B">Blue</option>
+        </select>
+    """
+    )
+    locator = page.locator("select")
+    await locator.select_option(["R", "G"])
+    await expect(locator).to_have_values(["R", "G"])
+
+
+async def test_to_have_values_follows_labels(page: Page, server: Server) -> None:
+    await page.set_content(
+        """
+        <label for="colors">Pick a Color</label>
+        <select id="colors" multiple>
+            <option value="R">Red</option>
+            <option value="G">Green</option>
+            <option value="B">Blue</option>
+        </select>
+    """
+    )
+    locator = page.locator("text=Pick a Color")
+    await locator.select_option(["R", "G"])
+    await expect(locator).to_have_values(["R", "G"])
+
+
+async def test_to_have_values_exact_match_with_text(page: Page, server: Server) -> None:
+    await page.set_content(
+        """
+        <select multiple>
+            <option value="RR">Red</option>
+            <option value="GG">Green</option>
+        </select>
+    """
+    )
+    locator = page.locator("select")
+    await locator.select_option(["RR", "GG"])
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(locator).to_have_values(["R", "G"], timeout=500)
+    assert "Locator expected to have Values '['R', 'G']'" in str(excinfo.value)
+    assert "Actual value: ['RR', 'GG']" in str(excinfo.value)
+
+
+async def test_to_have_values_works_with_regex(page: Page, server: Server) -> None:
+    await page.set_content(
+        """
+        <select multiple>
+            <option value="R">Red</option>
+            <option value="G">Green</option>
+            <option value="B">Blue</option>
+        </select>
+    """
+    )
+    locator = page.locator("select")
+    await locator.select_option(["R", "G"])
+    await expect(locator).to_have_values([re.compile("R"), re.compile("G")])
+
+
+async def test_to_have_values_fails_when_items_not_selected(
+    page: Page, server: Server
+) -> None:
+    await page.set_content(
+        """
+        <select multiple>
+            <option value="R">Red</option>
+            <option value="G">Green</option>
+            <option value="B">Blue</option>
+        </select>
+    """
+    )
+    locator = page.locator("select")
+    await locator.select_option(["B"])
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(locator).to_have_values(["R", "G"], timeout=500)
+    assert "Locator expected to have Values '['R', 'G']'" in str(excinfo.value)
+    assert "Actual value: ['B']" in str(excinfo.value)
+
+
+async def test_to_have_values_fails_when_multiple_not_specified(
+    page: Page, server: Server
+) -> None:
+    await page.set_content(
+        """
+        <select>
+            <option value="R">Red</option>
+            <option value="G">Green</option>
+            <option value="B">Blue</option>
+        </select>
+    """
+    )
+    locator = page.locator("select")
+    await locator.select_option(["B"])
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(locator).to_have_values(["R", "G"], timeout=500)
+    assert "Error: Not a select element with a multiple attribute" in str(excinfo.value)
+
+
+async def test_to_have_values_fails_when_not_a_select_element(
+    page: Page, server: Server
+) -> None:
+    await page.set_content(
+        """
+        <input type="text">
+    """
+    )
+    locator = page.locator("input")
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(locator).to_have_values(["R", "G"], timeout=500)
+    assert "Error: Not a select element with a multiple attribute" in str(excinfo.value)
+
+
+async def test_assertions_locator_to_be_checked(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<input type=checkbox>")
+    my_checkbox = page.locator("input")
+    await expect(my_checkbox).not_to_be_checked()
+    with pytest.raises(AssertionError, match="Locator expected to be checked"):
+        await expect(my_checkbox).to_be_checked(timeout=100)
+    await expect(my_checkbox).to_be_checked(timeout=100, checked=False)
+    with pytest.raises(AssertionError):
+        await expect(my_checkbox).to_be_checked(timeout=100, checked=True)
+    await my_checkbox.check()
+    await expect(my_checkbox).to_be_checked(timeout=100, checked=True)
+    with pytest.raises(AssertionError, match="Locator expected to be unchecked"):
+        await expect(my_checkbox).to_be_checked(timeout=100, checked=False)
+    await expect(my_checkbox).to_be_checked()
+
+
+async def test_assertions_boolean_checked_with_intermediate_true(page: Page) -> None:
+    await page.set_content("<input type=checkbox></input>")
+    await page.locator("input").evaluate("e => e.indeterminate = true")
+    await expect(page.locator("input")).to_be_checked(indeterminate=True)
+
+
+async def test_assertions_boolean_checked_with_intermediate_true_and_checked(
+    page: Page,
+) -> None:
+    await page.set_content("<input type=checkbox></input>")
+    await page.locator("input").evaluate("e => e.indeterminate = true")
+    with pytest.raises(
+        AssertionError, match="Can't assert indeterminate and checked at the same time"
+    ):
+        await expect(page.locator("input")).to_be_checked(
+            checked=False, indeterminate=True
+        )
+
+
+async def test_assertions_boolean_fail_with_indeterminate_true(page: Page) -> None:
+    await page.set_content("<input type=checkbox></input>")
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_checked" with timeout 1000ms'
+    ):
+        await expect(page.locator("input")).to_be_checked(
+            indeterminate=True, timeout=1000
+        )
+
+
+async def test_assertions_locator_to_be_disabled_enabled(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<input type=checkbox>")
+    my_checkbox = page.locator("input")
+    await expect(my_checkbox).not_to_be_disabled()
+    await expect(my_checkbox).to_be_enabled()
+    with pytest.raises(AssertionError):
+        await expect(my_checkbox).to_be_disabled(timeout=100)
+    await my_checkbox.evaluate("e => e.disabled = true")
+    await expect(my_checkbox).to_be_disabled()
+    with pytest.raises(AssertionError, match="Locator expected to be enabled"):
+        await expect(my_checkbox).to_be_enabled(timeout=100)
+
+
+async def test_assertions_locator_to_be_enabled_with_true(page: Page) -> None:
+    await page.set_content("<button>Text</button>")
+    await expect(page.locator("button")).to_be_enabled(enabled=True)
+
+
+async def test_assertions_locator_to_be_enabled_with_false_throws_good_exception(
+    page: Page,
+) -> None:
+    await page.set_content("<button>Text</button>")
+    with pytest.raises(AssertionError, match="Locator expected to be disabled"):
+        await expect(page.locator("button")).to_be_enabled(enabled=False)
+
+
+async def test_assertions_locator_to_be_enabled_with_false(page: Page) -> None:
+    await page.set_content("<button disabled>Text</button>")
+    await expect(page.locator("button")).to_be_enabled(enabled=False)
+
+
+async def test_assertions_locator_to_be_enabled_with_not_and_false(page: Page) -> None:
+    await page.set_content("<button>Text</button>")
+    await expect(page.locator("button")).not_to_be_enabled(enabled=False)
+
+
+async def test_assertions_locator_to_be_enabled_eventually(page: Page) -> None:
+    await page.set_content("<button disabled>Text</button>")
+    await page.eval_on_selector(
+        "button",
+        """
+        button => setTimeout(() => {
+            button.removeAttribute('disabled');
+        }, 700);
+    """,
+    )
+    await expect(page.locator("button")).to_be_enabled()
+
+
+async def test_assertions_locator_to_be_enabled_eventually_with_not(page: Page) -> None:
+    await page.set_content("<button>Text</button>")
+    await page.eval_on_selector(
+        "button",
+        """
+        button => setTimeout(() => {
+            button.setAttribute('disabled', '');
+        }, 700);
+    """,
+    )
+    await expect(page.locator("button")).not_to_be_enabled()
+
+
+async def test_assertions_locator_to_be_editable(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<input></input>")
+    await expect(page.locator("input")).to_be_editable()
+
+
+async def test_assertions_locator_to_be_editable_throws(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<button disabled>Text</button>")
+    with pytest.raises(
+        AssertionError,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        await expect(page.locator("button")).not_to_be_editable()
+
+
+async def test_assertions_locator_to_be_editable_with_true(page: Page) -> None:
+    await page.set_content("<input></input>")
+    await expect(page.locator("input")).to_be_editable(editable=True)
+
+
+async def test_assertions_locator_to_be_editable_with_false(page: Page) -> None:
+    await page.set_content("<input readonly></input>")
+    await expect(page.locator("input")).to_be_editable(editable=False)
+
+
+async def test_assertions_locator_to_be_editable_with_false_and_throw_good_exception(
+    page: Page,
+) -> None:
+    await page.set_content("<input></input>")
+    with pytest.raises(AssertionError, match="Locator expected to be readonly"):
+        await expect(page.locator("input")).to_be_editable(editable=False)
+
+
+async def test_assertions_locator_to_be_editable_with_not_and_false(page: Page) -> None:
+    await page.set_content("<input></input>")
+    await expect(page.locator("input")).not_to_be_editable(editable=False)
+
+
+async def test_assertions_locator_to_be_empty(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content(
+        "<input value=text name=input1></input><input name=input2></input>"
+    )
+    await expect(page.locator("input[name=input1]")).not_to_be_empty()
+    await expect(page.locator("input[name=input2]")).to_be_empty()
+    with pytest.raises(AssertionError):
+        await expect(page.locator("input[name=input1]")).to_be_empty(timeout=100)
+
+
+async def test_assertions_locator_to_be_focused(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<input type=checkbox>")
+    my_checkbox = page.locator("input")
+    with pytest.raises(AssertionError):
+        await expect(my_checkbox).to_be_focused(timeout=100)
+    await my_checkbox.focus()
+    await expect(my_checkbox).to_be_focused()
+
+
+async def test_assertions_locator_to_be_hidden_visible(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div style='width: 50px; height: 50px;'>Something</div>")
+    my_checkbox = page.locator("div")
+    await expect(my_checkbox).to_be_visible()
+    with pytest.raises(AssertionError):
+        await expect(my_checkbox).to_be_hidden(timeout=100)
+    await my_checkbox.evaluate("e => e.style.display = 'none'")
+    await expect(my_checkbox).to_be_hidden()
+    with pytest.raises(AssertionError, match="Locator expected to be visible"):
+        await expect(my_checkbox).to_be_visible(timeout=100)
+
+
+async def test_assertions_locator_to_be_visible_with_true(page: Page) -> None:
+    await page.set_content("<button>hello</button>")
+    await expect(page.locator("button")).to_be_visible(visible=True)
+
+
+async def test_assertions_locator_to_be_visible_with_false(page: Page) -> None:
+    await page.set_content("<button hidden>hello</button>")
+    await expect(page.locator("button")).to_be_visible(visible=False)
+
+
+async def test_assertions_locator_to_be_visible_with_false_throws_good_exception(
+    page: Page,
+) -> None:
+    await page.set_content("<button>hello</button>")
+    with pytest.raises(AssertionError, match="Locator expected to be hidden"):
+        await expect(page.locator("button")).to_be_visible(visible=False)
+
+
+async def test_assertions_locator_to_be_visible_with_not_and_false(page: Page) -> None:
+    await page.set_content("<button>hello</button>")
+    await expect(page.locator("button")).not_to_be_visible(visible=False)
+
+
+async def test_assertions_locator_to_be_visible_eventually(page: Page) -> None:
+    await page.set_content("<div></div>")
+    await page.eval_on_selector(
+        "div",
+        """
+        div => setTimeout(() => {
+            div.innerHTML = '<span>Hello</span>';
+        }, 700);
+    """,
+    )
+    await expect(page.locator("span")).to_be_visible()
+
+
+async def test_assertions_locator_to_be_visible_eventually_with_not(page: Page) -> None:
+    await page.set_content("<div><span>Hello</span></div>")
+    await page.eval_on_selector(
+        "span",
+        """
+        span => setTimeout(() => {
+            span.textContent = '';
+        }, 700);
+    """,
+    )
+    await expect(page.locator("span")).not_to_be_visible()
+
+
+async def test_assertions_should_serialize_regexp_correctly(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<div>iGnOrEcAsE</div>")
+    await expect(page.locator("div")).to_have_text(
+        re.compile(r"ignorecase", re.IGNORECASE)
+    )
+    await page.set_content(
+        """<div>start
+some
+lines
+between
+end</div>"""
+    )
+    await expect(page.locator("div")).to_have_text(re.compile(r"start.*end", re.DOTALL))
+    await page.set_content(
+        """<div>line1
+line2
+line3</div>"""
+    )
+    await expect(page.locator("div")).to_have_text(re.compile(r"^line2$", re.MULTILINE))
+
+
+async def test_assertions_response_is_ok_pass(page: Page, server: Server) -> None:
+    response = await page.request.get(server.EMPTY_PAGE)
+    await expect(response).to_be_ok()
+
+
+async def test_assertions_response_is_ok_pass_with_not(
+    page: Page, server: Server
+) -> None:
+    response = await page.request.get(server.PREFIX + "/unknown")
+    await expect(response).not_to_be_ok()
+
+
+async def test_assertions_response_is_ok_fail(page: Page, server: Server) -> None:
+    response = await page.request.get(server.PREFIX + "/unknown")
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(response).to_be_ok()
+    error_message = str(excinfo.value)
+    assert ("→ GET " + server.PREFIX + "/unknown") in error_message
+    assert "← 404 Not Found" in error_message
+
+
+async def test_should_print_response_with_text_content_type_if_to_be_ok_fails(
+    page: Page, server: Server
+) -> None:
+    server.set_route(
+        "/text-content-type",
+        lambda r: (
+            r.setResponseCode(404),
+            r.setHeader("content-type", "text/plain"),
+            r.write(b"Text error"),
+            r.finish(),
+        ),
+    )
+    server.set_route(
+        "/no-content-type",
+        lambda r: (
+            r.setResponseCode(404),
+            r.write(b"No content type error"),
+            r.finish(),
+        ),
+    )
+    server.set_route(
+        "/binary-content-type",
+        lambda r: (
+            r.setResponseCode(404),
+            r.setHeader("content-type", "image/bmp"),
+            r.write(b"Image content type error"),
+            r.finish(),
+        ),
+    )
+
+    response = await page.request.get(server.PREFIX + "/text-content-type")
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(response).to_be_ok()
+    error_message = str(excinfo.value)
+    assert ("→ GET " + server.PREFIX + "/text-content-type") in error_message
+    assert "← 404 Not Found" in error_message
+    assert "Response Text:" in error_message
+    assert "Text error" in error_message
+
+    response = await page.request.get(server.PREFIX + "/no-content-type")
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(response).to_be_ok()
+    error_message = str(excinfo.value)
+    assert ("→ GET " + server.PREFIX + "/no-content-type") in error_message
+    assert "← 404 Not Found" in error_message
+    assert "Response Text:" not in error_message
+    assert "No content type error" not in error_message
+
+    response = await page.request.get(server.PREFIX + "/binary-content-type")
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(response).to_be_ok()
+    error_message = str(excinfo.value)
+    assert ("→ GET " + server.PREFIX + "/binary-content-type") in error_message
+    assert "← 404 Not Found" in error_message
+    assert "Response Text:" not in error_message
+    assert "Image content type error" not in error_message
+
+
+async def test_should_print_users_message_for_page_based_assertion(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<title>new title</title>")
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(page, "Title is not new").to_have_title("old title", timeout=100)
+    assert "Title is not new" in str(excinfo.value)
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(page).to_have_title("old title", timeout=100)
+    assert "Page title expected to be" in str(excinfo.value)
+
+
+async def test_should_print_expected_value_with_custom_message(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<title>new title</title>")
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(page, "custom-message").to_have_title("old title", timeout=100)
+    assert "custom-message" in str(excinfo.value)
+    assert "Expected value: 'old title'" in str(excinfo.value)
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(page.get_by_text("hello"), "custom-message").to_be_visible(
+            timeout=100
+        )
+    assert "custom-message" in str(excinfo.value)
+    assert "Expected value" not in str(excinfo.value)
+
+
+async def test_should_be_attached_default(page: Page) -> None:
+    await page.set_content("<input></input>")
+    locator = page.locator("input")
+    await expect(locator).to_be_attached()
+
+
+async def test_should_be_attached_with_hidden_element(page: Page) -> None:
+    await page.set_content('<button style="display:none">hello</button>')
+    locator = page.locator("button")
+    await expect(locator).to_be_attached()
+
+
+async def test_should_be_attached_with_not(page: Page) -> None:
+    await page.set_content("<button>hello</button>")
+    locator = page.locator("input")
+    await expect(locator).not_to_be_attached()
+
+
+async def test_should_be_attached_with_attached_true(page: Page) -> None:
+    await page.set_content("<button>hello</button>")
+    locator = page.locator("button")
+    await expect(locator).to_be_attached(attached=True)
+
+
+async def test_should_be_attached_with_attached_false(page: Page) -> None:
+    await page.set_content("<button>hello</button>")
+    locator = page.locator("input")
+    await expect(locator).to_be_attached(attached=False)
+
+
+async def test_should_be_attached_with_attached_false_and_throw_good_error(
+    page: Page,
+) -> None:
+    await page.set_content("<button>hello</button>")
+    locator = page.locator("button")
+    with pytest.raises(AssertionError, match="Locator expected to be detached"):
+        await expect(locator).to_be_attached(attached=False, timeout=1)
+
+
+async def test_should_be_attached_with_not_and_attached_false(page: Page) -> None:
+    await page.set_content("<button>hello</button>")
+    locator = page.locator("button")
+    await expect(locator).not_to_be_attached(attached=False)
+
+
+async def test_should_be_attached_eventually(page: Page) -> None:
+    await page.set_content("<div></div>")
+    locator = page.locator("span")
+    await page.locator("div").evaluate(
+        "(e) => setTimeout(() => e.innerHTML = '<span>hello</span>', 1000)"
+    )
+    await expect(locator).to_be_attached()
+
+
+async def test_should_be_attached_eventually_with_not(page: Page) -> None:
+    await page.set_content("<div><span>Hello</span></div>")
+    locator = page.locator("span")
+    await page.locator("div").evaluate(
+        "(e) => setTimeout(() => e.textContent = '', 1000)"
+    )
+    await expect(locator).not_to_be_attached()
+
+
+async def test_should_be_attached_fail(page: Page) -> None:
+    await page.set_content("<button>Hello</button>")
+    locator = page.locator("input")
+    with pytest.raises(
+        AssertionError, match="Locator expected to be attached"
+    ) as exc_info:
+        await expect(locator).to_be_attached(timeout=1000)
+    assert "locator resolved to" not in exc_info.value.args[0]
+
+
+async def test_should_be_attached_fail_with_not(page: Page) -> None:
+    await page.set_content("<input></input>")
+    locator = page.locator("input")
+    with pytest.raises(AssertionError) as exc_info:
+        await expect(locator).not_to_be_attached(timeout=1000)
+    assert "locator resolved to <input/>" in exc_info.value.args[0]
+
+
+async def test_should_be_attached_with_impossible_timeout(page: Page) -> None:
+    await page.set_content("<div id=node>Text content</div>")
+    await expect(page.locator("#node")).to_be_attached(timeout=1)
+
+
+async def test_should_be_attached_with_impossible_timeout_not(page: Page) -> None:
+    await page.set_content("<div id=node>Text content</div>")
+    await expect(page.locator("no-such-thing")).not_to_be_attached(timeout=1)
+
+
+async def test_should_be_attached_with_frame_locator(page: Page) -> None:
+    await page.set_content("<div></div>")
+    locator = page.frame_locator("iframe").locator("input")
+    task = asyncio.create_task(expect(locator).to_be_attached())
+    await page.wait_for_timeout(1000)
+    assert not task.done()
+    await page.set_content('<iframe srcdoc="<input>"></iframe>')
+    await task
+    assert task.done()
+
+
+async def test_should_be_attached_over_navigation(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    task = asyncio.create_task(expect(page.locator("input")).to_be_attached())
+    await page.wait_for_timeout(1000)
+    assert not task.done()
+    await page.goto(server.PREFIX + "/input/checkbox.html")
+    await task
+    assert task.done()
+
+
+async def test_should_be_able_to_set_custom_timeout(page: Page) -> None:
+    with pytest.raises(AssertionError) as exc_info:
+        await expect(page.locator("#a1")).to_be_visible(timeout=111)
+    assert 'Expect "to_be_visible" with timeout 111ms' in str(exc_info.value)
+
+
+async def test_should_be_able_to_set_custom_global_timeout(page: Page) -> None:
+    try:
+        expect.set_options(timeout=111)
+        with pytest.raises(AssertionError) as exc_info:
+            await expect(page.locator("#a1")).to_be_visible()
+        assert 'Expect "to_be_visible" with timeout 111ms' in str(exc_info.value)
+    finally:
+        expect.set_options(timeout=None)
+
+
+async def test_to_have_accessible_name(page: Page) -> None:
+    await page.set_content('<div role="button" aria-label="Hello"></div>')
+    locator = page.locator("div")
+    await expect(locator).to_have_accessible_name("Hello")
+    await expect(locator).not_to_have_accessible_name("hello")
+    await expect(locator).to_have_accessible_name("hello", ignore_case=True)
+    await expect(locator).to_have_accessible_name(re.compile(r"ell\w"))
+    await expect(locator).not_to_have_accessible_name(re.compile(r"hello"))
+    await expect(locator).to_have_accessible_name(
+        re.compile(r"hello"), ignore_case=True
+    )
+
+    await page.set_content("<button>foo&nbsp;bar\nbaz</button>")
+    await expect(page.locator("button")).to_have_accessible_name("foo bar baz")
+
+
+async def test_to_have_accessible_error_message(page: Page) -> None:
+    await page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error-message" />
+        <div id="error-message">Hello</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+    await expect(locator).to_have_accessible_error_message("Hello")
+    await expect(locator).not_to_have_accessible_error_message("hello")
+    await expect(locator).to_have_accessible_error_message("hello", ignore_case=True)
+    await expect(locator).to_have_accessible_error_message(re.compile(r"ell\w"))
+    await expect(locator).not_to_have_accessible_error_message(re.compile(r"hello"))
+    await expect(locator).to_have_accessible_error_message(
+        re.compile(r"hello"), ignore_case=True
+    )
+    await expect(locator).not_to_have_accessible_error_message(
+        "This should not be considered."
+    )
+
+
+async def test_to_have_accessible_error_message_should_handle_multiple_aria_error_message_references(
+    page: Page,
+) -> None:
+    await page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error1 error2" />
+        <div id="error1">First error message.</div>
+        <div id="error2">Second error message.</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+
+    await expect(locator).to_have_accessible_error_message(
+        "First error message. Second error message."
+    )
+    await expect(locator).to_have_accessible_error_message(
+        re.compile(r"first error message.", re.IGNORECASE)
+    )
+    await expect(locator).to_have_accessible_error_message(
+        re.compile(r"second error message.", re.IGNORECASE)
+    )
+    await expect(locator).not_to_have_accessible_error_message(
+        re.compile(r"This should not be considered.", re.IGNORECASE)
+    )
+
+
+async def test_to_have_accessible_description(page: Page) -> None:
+    await page.set_content('<div role="button" aria-description="Hello"></div>')
+    locator = page.locator("div")
+    await expect(locator).to_have_accessible_description("Hello")
+    await expect(locator).not_to_have_accessible_description("hello")
+    await expect(locator).to_have_accessible_description("hello", ignore_case=True)
+    await expect(locator).to_have_accessible_description(re.compile(r"ell\w"))
+    await expect(locator).not_to_have_accessible_description(re.compile(r"hello"))
+    await expect(locator).to_have_accessible_description(
+        re.compile(r"hello"), ignore_case=True
+    )
+
+    await page.set_content(
+        """
+        <div role="button" aria-describedby="desc"></div>
+        <span id="desc">foo&nbsp;bar\nbaz</span>
+    """
+    )
+    await expect(page.locator("div")).to_have_accessible_description("foo bar baz")
+
+
+async def test_to_have_role(page: Page) -> None:
+    await page.set_content('<div role="button">Button!</div>')
+    await expect(page.locator("div")).to_have_role("button")
+    await expect(page.locator("div")).not_to_have_role("checkbox")
+    with pytest.raises(Error) as excinfo:
+        await expect(page.locator("div")).to_have_role(re.compile(r"button|checkbox"))  # type: ignore
+    assert '"role" argument in to_have_role must be a string' in str(excinfo.value)
+
+
+async def test_soft_outside_scope_raises_runtime_error(
+    page: Page, server: Server
+) -> None:
+    await page.set_content("<div>hello</div>")
+    with pytest.raises(RuntimeError, match="pytest-playwright"):
+        await expect.soft(page.locator("div")).to_have_text("nope", timeout=500)
+
+
+async def test_soft_inside_scope_collects_failures(page: Page, server: Server) -> None:
+    from playwright._impl._assertions import _soft_scope
+
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<title>actual</title><div>hello</div>")
+
+    with _soft_scope() as errors:
+        # should collect, not raise
+        await expect.soft(page).to_have_title("expected", timeout=500)
+        await expect.soft(page.locator("div")).to_have_text("goodbye", timeout=500)
+        # passing soft should not affect the collector
+        await expect.soft(page.locator("div")).to_have_text("hello")
+        # nested .not_ should still be soft
+        await expect.soft(page.locator("div")).not_to_have_text("hello", timeout=500)
+
+    assert len(errors) == 3
+    assert all(isinstance(e, AssertionError) for e in errors)
+
+
+async def test_soft_does_not_leak_between_scopes(page: Page, server: Server) -> None:
+    from playwright._impl._assertions import _soft_scope
+
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<title>actual</title>")
+
+    with _soft_scope() as errors_a:
+        await expect.soft(page).to_have_title("nope", timeout=500)
+    assert len(errors_a) == 1
+
+    with _soft_scope() as errors_b:
+        pass
+    assert errors_b == []
+
+    # After scope ends, soft assertions raise RuntimeError again.
+    await page.set_content("<div>hello</div>")
+    with pytest.raises(RuntimeError, match="pytest-playwright"):
+        await expect.soft(page.locator("div")).to_have_text("nope", timeout=500)
+
+
+async def test_assertions_should_include_aria_snapshot_in_separate_section(
+    page: Page,
+) -> None:
+    await page.set_content(
+        """
+        <div id="hidden" style="display: none"><span>secret</span></div>
+        <main><h1>Page Heading</h1></main>
+        """
+    )
+    with pytest.raises(AssertionError) as excinfo:
+        await expect(page.locator("#hidden")).to_be_visible(timeout=500)
+    message = str(excinfo.value)
+    assert "Aria snapshot:" in message
+    # The aria snapshot lives in its own section, not in the "Actual value" line.
+    assert "Actual value: hidden" in message
+    actual_line = message.split("\n")[1]
+    assert 'heading "Page Heading"' not in actual_line
+    assert message.index('heading "Page Heading"') > message.index("Aria snapshot:")
diff --git a/tests/async/test_asyncio.py b/tests/async/test_asyncio.py
new file mode 100644
index 000000000..c78648430
--- /dev/null
+++ b/tests/async/test_asyncio.py
@@ -0,0 +1,144 @@
+# 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 asyncio
+import gc
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+from typing import Dict
+
+import pytest
+
+from playwright.async_api import Page, async_playwright
+from tests.server import Server
+from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
+
+
+async def test_should_cancel_underlying_protocol_calls(
+    browser_name: str, launch_arguments: Dict
+) -> None:
+    handler_exception = None
+
+    def exception_handlerdler(loop: asyncio.AbstractEventLoop, context: Dict) -> None:
+        nonlocal handler_exception
+        handler_exception = context["exception"]
+
+    asyncio.get_running_loop().set_exception_handler(exception_handlerdler)
+
+    async with async_playwright() as p:
+        browser = await p[browser_name].launch(**launch_arguments)
+        page = await browser.new_page()
+        task = asyncio.create_task(page.wait_for_selector("will-never-find"))
+        # make sure that the wait_for_selector message was sent to the server (driver)
+        await asyncio.sleep(0.1)
+        task.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await task
+        await browser.close()
+
+    # The actual 'Future exception was never retrieved' is logged inside the Future destructor (__del__).
+    gc.collect()
+
+    assert handler_exception is None
+
+    asyncio.get_running_loop().set_exception_handler(None)
+
+
+async def test_async_playwright_stop_multiple_times() -> None:
+    playwright = await async_playwright().start()
+    await playwright.stop()
+    await playwright.stop()
+
+
+async def test_cancel_pending_protocol_call_on_playwright_stop(server: Server) -> None:
+    server.set_route("/hang", lambda _: None)
+    playwright = await async_playwright().start()
+    api_request_context = await playwright.request.new_context()
+    pending_task = asyncio.create_task(api_request_context.get(server.PREFIX + "/hang"))
+    await playwright.stop()
+    with pytest.raises(Exception) as exc_info:
+        await pending_task
+    assert TARGET_CLOSED_ERROR_MESSAGE in str(exc_info.value)
+
+
+async def test_should_not_throw_with_taskgroup(page: Page) -> None:
+    if sys.version_info < (3, 11):
+        pytest.skip("TaskGroup is only available in Python 3.11+")
+
+    from builtins import ExceptionGroup  # type: ignore
+
+    async def raise_exception() -> None:
+        raise ValueError("Something went wrong")
+
+    with pytest.raises(ExceptionGroup) as exc_info:
+        async with asyncio.TaskGroup() as group:  # type: ignore
+            group.create_task(page.locator(".this-element-does-not-exist").inner_text())
+            group.create_task(raise_exception())
+    assert len(exc_info.value.exceptions) == 1
+    assert "Something went wrong" in str(exc_info.value.exceptions[0])
+    assert isinstance(exc_info.value.exceptions[0], ValueError)
+    assert await page.evaluate("() => 11 * 11") == 121
+
+
+def test_stop_does_not_deadlock_with_asyncio_atexit(tmp_path: Path) -> None:
+    # Regression test for https://github.com/microsoft/playwright-python/issues/3004.
+    # asyncio.run() cancels all remaining tasks (including transport.run()) before
+    # calling loop.close(). asyncio-atexit hooks loop.close() to run async cleanup,
+    # so awaiting playwright.stop() at that point used to deadlock on a future that
+    # the (already cancelled) run task would never set.
+    script = tmp_path / "atexit_stop.py"
+    script.write_text(
+        textwrap.dedent(
+            """
+            import asyncio
+
+            import asyncio_atexit
+            from playwright.async_api import async_playwright
+
+
+            async def main():
+                pw = await async_playwright().start()
+                asyncio_atexit.register(lambda: stop(pw))
+
+
+            async def stop(pw):
+                await pw.stop()
+                print("STOPPED", flush=True)
+
+
+            asyncio.run(main())
+            """
+        )
+    )
+    result = subprocess.run(
+        [sys.executable, str(script)],
+        capture_output=True,
+        text=True,
+        timeout=30,
+    )
+    assert result.returncode == 0, result.stderr
+    assert "STOPPED" in result.stdout
+
+
+async def test_should_return_proper_api_name_on_error(page: Page) -> None:
+    try:
+        await page.evaluate("does_not_exist")
+
+        assert (
+            False
+        ), "Accessing undefined JavaScript variable should have thrown exception"
+    except Exception as error:
+        # Each browser returns slightly different error messages, but they should all start with "Page.evaluate:", because that was the Playwright method where the error originated
+        assert str(error).startswith("Page.evaluate:")
diff --git a/tests/async/test_browser.py b/tests/async/test_browser.py
index dbc1c2442..8aa0f48d6 100644
--- a/tests/async/test_browser.py
+++ b/tests/async/test_browser.py
@@ -1,6 +1,6 @@
 # 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
 #
@@ -13,13 +13,14 @@
 # limitations under the License.
 
 import re
+from typing import Dict
 
 import pytest
 
-from playwright.async_api import Browser, Error
+from playwright.async_api import Browser, BrowserType, Error
 
 
-async def test_should_create_new_page(browser):
+async def test_should_create_new_page(browser: Browser) -> None:
     page1 = await browser.new_page()
     assert len(browser.contexts) == 1
 
@@ -33,17 +34,48 @@ async def test_should_create_new_page(browser):
     assert len(browser.contexts) == 0
 
 
-async def test_should_throw_upon_second_create_new_page(browser):
+async def test_should_throw_upon_second_create_new_page(browser: Browser) -> None:
     page = await browser.new_page()
     with pytest.raises(Error) as exc:
         await page.context.new_page()
     await page.close()
-    assert "Please use browser.newContext()" in exc.value.message
+    assert "Please use browser.new_context()" in exc.value.message
 
 
-async def test_version_should_work(browser: Browser, is_chromium):
+async def test_version_should_work(browser: Browser, is_chromium: bool) -> None:
     version = browser.version
     if is_chromium:
         assert re.match(r"^\d+\.\d+\.\d+\.\d+$", version)
     else:
         assert re.match(r"^\d+\.\d+", version)
+
+
+async def test_should_return_browser_type(
+    browser: Browser, browser_type: BrowserType
+) -> None:
+    assert browser.browser_type is browser_type
+
+
+async def test_bind_should_return_endpoint_and_allow_unbind(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
+    browser = await browser_type.launch(**launch_arguments)
+    try:
+        result = await browser.bind("test-server")
+        assert "endpoint" in result
+        assert isinstance(result["endpoint"], str)
+        assert len(result["endpoint"]) > 0
+        await browser.unbind()
+    finally:
+        await browser.close()
+
+
+async def test_should_fire_context_event_on_new_context(browser: Browser) -> None:
+    # Ported from upstream tests/library/browser.spec.ts.
+    events = []
+    browser.on("context", lambda ctx: events.append(ctx))
+    context = await browser.new_context()
+    try:
+        assert events == [context]
+    finally:
+        await context.close()
diff --git a/tests/async/test_browsercontext.py b/tests/async/test_browsercontext.py
index 90ebbfab7..388b0be9c 100644
--- a/tests/async/test_browsercontext.py
+++ b/tests/async/test_browsercontext.py
@@ -13,34 +13,55 @@
 # limitations under the License.
 
 import asyncio
+from typing import Any, List
+from urllib.parse import urlparse
 
 import pytest
 
-from playwright.async_api import Error
+from playwright.async_api import (
+    Browser,
+    BrowserContext,
+    Error,
+    Page,
+    Playwright,
+)
+from tests.server import Server
+from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
 
+from .utils import Utils
 
-async def test_page_event_should_create_new_context(browser):
+
+@pytest.fixture(scope="session")
+def fails_on_401(browser_name: str, is_headless_shell: bool) -> bool:
+    return browser_name == "chromium" and not is_headless_shell
+
+
+async def test_page_event_should_create_new_context(browser: Browser) -> None:
     assert len(browser.contexts) == 0
     context = await browser.new_context()
     assert len(browser.contexts) == 1
     assert context in browser.contexts
     await context.close()
     assert len(browser.contexts) == 0
+    assert context.browser == browser
 
 
-async def test_window_open_should_use_parent_tab_context(browser, server):
+async def test_window_open_should_use_parent_tab_context(
+    browser: Browser, server: Server
+) -> None:
     context = await browser.new_context()
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
-    [popup, _] = await asyncio.gather(
-        page.wait_for_event("popup"),
-        page.evaluate("url => window.open(url)", server.EMPTY_PAGE),
-    )
+    async with page.expect_popup() as page_info:
+        await page.evaluate("url => window.open(url)", server.EMPTY_PAGE)
+    popup = await page_info.value
     assert popup.context == context
     await context.close()
 
 
-async def test_page_event_should_isolate_localStorage_and_cookies(browser, server):
+async def test_page_event_should_isolate_localStorage_and_cookies(
+    browser: Browser, server: Server
+) -> None:
     # Create two incognito contexts.
     context1 = await browser.new_context()
     context2 = await browser.new_context()
@@ -86,55 +107,58 @@ async def test_page_event_should_isolate_localStorage_and_cookies(browser, serve
     assert browser.contexts == []
 
 
-async def test_page_event_should_propagate_default_viewport_to_the_page(browser, utils):
-    context = await browser.new_context(viewport=(456, 789))
+async def test_page_event_should_propagate_default_viewport_to_the_page(
+    browser: Browser, utils: Utils
+) -> None:
+    context = await browser.new_context(viewport={"width": 456, "height": 789})
     page = await context.new_page()
     await utils.verify_viewport(page, 456, 789)
     await context.close()
 
 
-async def test_page_event_should_respect_device_scale_factor(browser):
-    context = await browser.new_context(device_scale_factor=3)
+async def test_page_event_should_respect_device_scale_factor(browser: Browser) -> None:
+    context = await browser.new_context(device_scale_factor=3.5)
     page = await context.new_page()
-    assert await page.evaluate("window.devicePixelRatio") == 3
+    assert await page.evaluate("window.devicePixelRatio") == 3.5
     await context.close()
 
 
 async def test_page_event_should_not_allow_device_scale_factor_with_null_viewport(
-    browser,
-):
+    browser: Browser,
+) -> None:
     with pytest.raises(Error) as exc_info:
-        await browser.new_context(viewport=0, device_scale_factor=1)
+        await browser.new_context(no_viewport=True, device_scale_factor=1)
     assert (
         exc_info.value.message
-        == '"deviceScaleFactor" option is not supported with null "viewport"'
+        == 'Browser.new_context: "deviceScaleFactor" option is not supported with null "viewport"'
     )
 
 
-async def test_page_event_should_not_allow_is_mobile_with_null_viewport(browser):
+async def test_page_event_should_not_allow_is_mobile_with_null_viewport(
+    browser: Browser,
+) -> None:
     with pytest.raises(Error) as exc_info:
-        await browser.new_context(viewport=0, is_mobile=True)
+        await browser.new_context(no_viewport=True, is_mobile=True)
     assert (
         exc_info.value.message
-        == '"isMobile" option is not supported with null "viewport"'
+        == 'Browser.new_context: "isMobile" option is not supported with null "viewport"'
     )
 
 
-async def test_close_should_work_for_empty_context(browser):
+async def test_close_should_work_for_empty_context(browser: Browser) -> None:
     context = await browser.new_context()
     await context.close()
 
 
-async def test_close_should_abort_wait_for_event(browser):
+async def test_close_should_abort_wait_for_event(browser: Browser) -> None:
     context = await browser.new_context()
-    promise = asyncio.create_task(context.wait_for_event("page"))
-    await context.close()
     with pytest.raises(Error) as exc_info:
-        await promise
-    assert "Context closed" in exc_info.value.message
+        async with context.expect_page():
+            await context.close()
+    assert TARGET_CLOSED_ERROR_MESSAGE in exc_info.value.message
 
 
-async def test_close_should_be_callable_twice(browser):
+async def test_close_should_be_callable_twice(browser: Browser) -> None:
     context = await browser.new_context()
     await asyncio.gather(
         context.close(),
@@ -143,8 +167,15 @@ async def test_close_should_be_callable_twice(browser):
     await context.close()
 
 
-async def test_user_agent_should_work(browser, server):
-    async def baseline():
+async def test_is_closed_should_reflect_state(browser: Browser) -> None:
+    context = await browser.new_context()
+    assert context.is_closed() is False
+    await context.close()
+    assert context.is_closed() is True
+
+
+async def test_user_agent_should_work(browser: Browser, server: Server) -> None:
+    async def baseline() -> None:
         context = await browser.new_context()
         page = await context.new_page()
         assert "Mozilla" in await page.evaluate("navigator.userAgent")
@@ -152,7 +183,7 @@ async def baseline():
 
     await baseline()
 
-    async def override():
+    async def override() -> None:
         context = await browser.new_context(user_agent="foobar")
         page = await context.new_page()
         [request, _] = await asyncio.gather(
@@ -165,7 +196,9 @@ async def override():
     await override()
 
 
-async def test_user_agent_should_work_for_subframes(browser, server, utils):
+async def test_user_agent_should_work_for_subframes(
+    browser: Browser, server: Server, utils: Utils
+) -> None:
     context = await browser.new_context(user_agent="foobar")
     page = await context.new_page()
     [request, _] = await asyncio.gather(
@@ -176,7 +209,9 @@ async def test_user_agent_should_work_for_subframes(browser, server, utils):
     await context.close()
 
 
-async def test_user_agent_should_emulate_device_user_agent(playwright, browser, server):
+async def test_user_agent_should_emulate_device_user_agent(
+    playwright: Playwright, browser: Browser, server: Server
+) -> None:
     context = await browser.new_context(
         user_agent=playwright.devices["iPhone 6"]["user_agent"]
     )
@@ -186,8 +221,10 @@ async def test_user_agent_should_emulate_device_user_agent(playwright, browser,
     await context.close()
 
 
-async def test_user_agent_should_make_a_copy_of_default_options(browser, server):
-    options = {"user_agent": "foobar"}
+async def test_user_agent_should_make_a_copy_of_default_options(
+    browser: Browser, server: Server
+) -> None:
+    options: Any = {"user_agent": "foobar"}
     context = await browser.new_context(**options)
     options["user_agent"] = "wrong"
     page = await context.new_page()
@@ -199,8 +236,10 @@ async def test_user_agent_should_make_a_copy_of_default_options(browser, server)
     await context.close()
 
 
-async def test_page_event_should_bypass_csp_meta_tag(browser, server):
-    async def baseline():
+async def test_page_event_should_bypass_csp_meta_tag(
+    browser: Browser, server: Server
+) -> None:
+    async def baseline() -> None:
         context = await browser.new_context()
         page = await context.new_page()
         await page.goto(server.PREFIX + "/csp.html")
@@ -214,7 +253,7 @@ async def baseline():
     await baseline()
 
     # By-pass CSP and try one more time.
-    async def override():
+    async def override() -> None:
         context = await browser.new_context(bypass_csp=True)
         page = await context.new_page()
         await page.goto(server.PREFIX + "/csp.html")
@@ -225,11 +264,13 @@ async def override():
     await override()
 
 
-async def test_page_event_should_bypass_csp_header(browser, server):
+async def test_page_event_should_bypass_csp_header(
+    browser: Browser, server: Server
+) -> None:
     # Make sure CSP prohibits add_script_tag.
     server.set_csp("/empty.html", 'default-src "self"')
 
-    async def baseline():
+    async def baseline() -> None:
         context = await browser.new_context()
         page = await context.new_page()
         await page.goto(server.EMPTY_PAGE)
@@ -243,7 +284,7 @@ async def baseline():
     await baseline()
 
     # By-pass CSP and try one more time.
-    async def override():
+    async def override() -> None:
         context = await browser.new_context(bypass_csp=True)
         page = await context.new_page()
         await page.goto(server.EMPTY_PAGE)
@@ -254,7 +295,9 @@ async def override():
     await override()
 
 
-async def test_page_event_should_bypass_after_cross_process_navigation(browser, server):
+async def test_page_event_should_bypass_after_cross_process_navigation(
+    browser: Browser, server: Server
+) -> None:
     context = await browser.new_context(bypass_csp=True)
     page = await context.new_page()
     await page.goto(server.PREFIX + "/csp.html")
@@ -267,8 +310,10 @@ async def test_page_event_should_bypass_after_cross_process_navigation(browser,
     await context.close()
 
 
-async def test_page_event_should_bypass_csp_in_iframes_as_well(browser, server, utils):
-    async def baseline():
+async def test_page_event_should_bypass_csp_in_iframes_as_well(
+    browser: Browser, server: Server, utils: Utils
+) -> None:
+    async def baseline() -> None:
         # Make sure CSP prohibits add_script_tag in an iframe.
         context = await browser.new_context()
         page = await context.new_page()
@@ -284,7 +329,7 @@ async def baseline():
     await baseline()
 
     # By-pass CSP and try one more time.
-    async def override():
+    async def override() -> None:
         context = await browser.new_context(bypass_csp=True)
         page = await context.new_page()
         await page.goto(server.EMPTY_PAGE)
@@ -299,8 +344,8 @@ async def override():
     await override()
 
 
-async def test_csp_should_work(browser, is_webkit):
-    async def baseline():
+async def test_csp_should_work(browser: Browser, is_webkit: bool) -> None:
+    async def baseline() -> None:
         context = await browser.new_context(java_script_enabled=False)
         page = await context.new_page()
         await page.goto('data:text/html, <script>var something = "forbidden"</script>')
@@ -314,7 +359,7 @@ async def baseline():
 
     await baseline()
 
-    async def override():
+    async def override() -> None:
         context = await browser.new_context()
         page = await context.new_page()
         await page.goto('data:text/html, <script>var something = "forbidden"</script>')
@@ -325,15 +370,17 @@ async def override():
 
 
 async def test_csp_should_be_able_to_navigate_after_disabling_javascript(
-    browser, server
-):
+    browser: Browser, server: Server
+) -> None:
     context = await browser.new_context(java_script_enabled=False)
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
     await context.close()
 
 
-async def test_pages_should_return_all_of_the_pages(context, server):
+async def test_pages_should_return_all_of_the_pages(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     second = await context.new_page()
     all_pages = context.pages
@@ -342,17 +389,19 @@ async def test_pages_should_return_all_of_the_pages(context, server):
     assert second in all_pages
 
 
-async def test_pages_should_close_all_belonging_pages_once_closing_context(context):
+async def test_pages_should_close_all_belonging_pages_once_closing_context(
+    context: BrowserContext,
+) -> None:
     await context.new_page()
     assert len(context.pages) == 1
     await context.close()
     assert context.pages == []
 
 
-async def test_expose_binding_should_work(context):
+async def test_expose_binding_should_work(context: BrowserContext) -> None:
     binding_source = []
 
-    def binding(source, a, b):
+    def binding(source: Any, a: int, b: int) -> int:
         binding_source.append(source)
         return a + b
 
@@ -366,7 +415,7 @@ def binding(source, a, b):
     assert result == 11
 
 
-async def test_expose_function_should_work(context):
+async def test_expose_function_should_work(context: BrowserContext) -> None:
     await context.expose_function("add", lambda a, b: a + b)
     page = await context.new_page()
     await page.expose_function("mul", lambda a, b: a * b)
@@ -381,8 +430,8 @@ async def test_expose_function_should_work(context):
 
 
 async def test_expose_function_should_throw_for_duplicate_registrations(
-    context, server
-):
+    context: BrowserContext, server: Server
+) -> None:
     await context.expose_function("foo", lambda: None)
     await context.expose_function("bar", lambda: None)
     with pytest.raises(Error) as exc_info:
@@ -404,188 +453,200 @@ async def test_expose_function_should_throw_for_duplicate_registrations(
     )
 
 
-async def test_expose_function_should_be_callable_from_inside_addInitScript(
-    context, server
-):
+async def test_expose_function_should_be_callable_from_inside_add_init_script(
+    context: BrowserContext, server: Server
+) -> None:
     args = []
     await context.expose_function("woof", lambda arg: args.append(arg))
     await context.add_init_script("woof('context')")
     page = await context.new_page()
-    await page.add_init_script("woof('page')")
+    await page.evaluate("undefined")
+    assert args == ["context"]
     args = []
+    await page.add_init_script("woof('page')")
     await page.reload()
     assert args == ["context", "page"]
 
 
-async def test_expose_bindinghandle_should_work(context):
-    targets = []
-
-    def logme(t):
-        targets.append(t)
-        return 17
-
+async def test_auth_should_fail_without_credentials(
+    context: BrowserContext, server: Server, fails_on_401: bool
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
     page = await context.new_page()
-    await page.expose_binding("logme", lambda source, t: logme(t), handle=True)
-    result = await page.evaluate("logme({ foo: 42 })")
-    assert (await targets[0].evaluate("x => x.foo")) == 42
-    assert result == 17
-
+    try:
+        response = await page.goto(server.EMPTY_PAGE)
+        assert response
+        assert response.status == 401
+    except Error as exc:
+        assert fails_on_401
+        assert "net::ERR_INVALID_AUTH_CREDENTIALS" in exc.message
 
-async def test_route_should_intercept(context, server):
-    intercepted = []
 
-    def handle(route, request):
-        intercepted.append(True)
-        assert "empty.html" in request.url
-        assert request.headers["user-agent"]
-        assert request.method == "GET"
-        assert request.post_data is None
-        assert request.is_navigation_request
-        assert request.resource_type == "document"
-        assert request.frame == page.main_frame
-        assert request.frame.url == "about:blank"
-        asyncio.create_task(route.continue_())
-
-    await context.route("**/empty.html", lambda route, request: handle(route, request))
+async def test_auth_should_work_with_correct_credentials(
+    browser: Browser, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    context = await browser.new_context(
+        http_credentials={"username": "user", "password": "pass"}
+    )
     page = await context.new_page()
     response = await page.goto(server.EMPTY_PAGE)
-    assert response.ok
-    assert intercepted == [True]
+    assert response
+    assert response.status == 200
     await context.close()
 
 
-async def test_route_should_unroute(context, server):
-    page = await context.new_page()
-
-    intercepted = []
-
-    def handler(route, request, ordinal):
-        intercepted.append(ordinal)
-        asyncio.create_task(route.continue_())
-
-    def handler1(route, request):
-        handler(route, request, 1)
-
-    await context.route("**/empty.html", handler1)
-    await context.route(
-        "**/empty.html", lambda route, request: handler(route, request, 2)
-    )
-    await context.route(
-        "**/empty.html", lambda route, request: handler(route, request, 3)
+async def test_auth_should_fail_with_wrong_credentials(
+    browser: Browser, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    context = await browser.new_context(
+        http_credentials={"username": "foo", "password": "bar"}
     )
-    await context.route("**/*", lambda route, request: handler(route, request, 4))
-
-    await page.goto(server.EMPTY_PAGE)
-    assert intercepted == [1]
-
-    intercepted = []
-    await context.unroute("**/empty.html", handler1)
-    await page.goto(server.EMPTY_PAGE)
-    assert intercepted == [2]
-
-    intercepted = []
-    await context.unroute("**/empty.html")
-    await page.goto(server.EMPTY_PAGE)
-    assert intercepted == [4]
+    page = await context.new_page()
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 401
+    await context.close()
 
 
-async def test_route_should_yield_to_page_route(context, server):
-    await context.route(
-        "**/empty.html",
-        lambda route, request: asyncio.create_task(
-            route.fulfill(status=200, body="context")
-        ),
+async def test_auth_should_return_resource_body(
+    browser: Browser, server: Server
+) -> None:
+    server.set_auth("/playground.html", "user", "pass")
+    context = await browser.new_context(
+        http_credentials={"username": "user", "password": "pass"}
     )
-
     page = await context.new_page()
-    await page.route(
-        "**/empty.html",
-        lambda route, request: asyncio.create_task(
-            route.fulfill(status=200, body="page")
-        ),
-    )
-
-    response = await page.goto(server.EMPTY_PAGE)
-    assert response.ok
-    assert await response.text() == "page"
+    response = await page.goto(server.PREFIX + "/playground.html")
+    assert response
+    assert response.status == 200
+    assert await page.title() == "Playground"
+    assert "Playground" in await response.text()
+    await context.close()
 
 
-async def test_route_should_fall_back_to_context_route(context, server):
-    await context.route(
-        "**/empty.html",
-        lambda route, request: asyncio.create_task(
-            route.fulfill(status=200, body="context")
-        ),
+async def test_should_work_with_correct_credentials_and_matching_origin(
+    browser: Browser, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    context = await browser.new_context(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX,
+        }
     )
-
     page = await context.new_page()
-    await page.route(
-        "**/non-empty.html",
-        lambda route, request: asyncio.create_task(
-            route.fulfill(status=200, body="page")
-        ),
-    )
-
     response = await page.goto(server.EMPTY_PAGE)
-    assert response.ok
-    assert await response.text() == "context"
+    assert response
+    assert response.status == 200
+    await context.close()
 
 
-async def test_auth_should_fail_without_credentials(context, server):
-    server.set_auth("/empty.html", b"user", b"pass")
+async def test_should_work_with_correct_credentials_and_matching_origin_case_insensitive(
+    browser: Browser, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    context = await browser.new_context(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.upper(),
+        }
+    )
     page = await context.new_page()
     response = await page.goto(server.EMPTY_PAGE)
-    assert response.status == 401
+    assert response
+    assert response.status == 200
+    await context.close()
 
 
-async def test_auth_should_work_with_correct_credentials(browser, server):
-    server.set_auth("/empty.html", b"user", b"pass")
+async def test_should_fail_with_correct_credentials_and_mismatching_scheme(
+    browser: Browser, server: Server, fails_on_401: bool
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
     context = await browser.new_context(
-        http_credentials={"username": "user", "password": "pass"}
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.replace("http://", "https://"),
+        }
     )
     page = await context.new_page()
-    response = await page.goto(server.EMPTY_PAGE)
-    assert response.status == 200
+    try:
+        response = await page.goto(server.EMPTY_PAGE)
+        assert response
+        assert response.status == 401
+    except Error as exc:
+        assert fails_on_401
+        assert "net::ERR_INVALID_AUTH_CREDENTIALS" in exc.message
     await context.close()
 
 
-async def test_auth_should_fail_with_wrong_credentials(browser, server):
-    server.set_auth("/empty.html", b"user", b"pass")
+async def test_should_fail_with_correct_credentials_and_mismatching_hostname(
+    browser: Browser, server: Server, fails_on_401: bool
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    hostname = urlparse(server.PREFIX).hostname
+    assert hostname
+    origin = server.PREFIX.replace(hostname, "mismatching-hostname")
     context = await browser.new_context(
-        http_credentials={"username": "foo", "password": "bar"}
+        http_credentials={"username": "user", "password": "pass", "origin": origin}
     )
     page = await context.new_page()
-    response = await page.goto(server.EMPTY_PAGE)
-    assert response.status == 401
+    try:
+        response = await page.goto(server.EMPTY_PAGE)
+        assert response
+        assert response.status == 401
+    except Error as exc:
+        assert fails_on_401
+        assert "net::ERR_INVALID_AUTH_CREDENTIALS" in exc.message
     await context.close()
 
 
-async def test_auth_should_return_resource_body(browser, server):
-    server.set_auth("/playground.html", b"user", b"pass")
+async def test_should_fail_with_correct_credentials_and_mismatching_port(
+    browser: Browser, server: Server, fails_on_401: bool
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    origin = server.PREFIX.replace(str(server.PORT), str(server.PORT + 1))
     context = await browser.new_context(
-        http_credentials={"username": "user", "password": "pass"}
+        http_credentials={"username": "user", "password": "pass", "origin": origin}
     )
     page = await context.new_page()
-    response = await page.goto(server.PREFIX + "/playground.html")
-    assert response.status == 200
-    assert await page.title() == "Playground"
-    assert "Playground" in await response.text()
+    try:
+        response = await page.goto(server.EMPTY_PAGE)
+        assert response
+        assert response.status == 401
+    except Error as exc:
+        assert fails_on_401
+        assert "net::ERR_INVALID_AUTH_CREDENTIALS" in exc.message
     await context.close()
 
 
-async def test_offline_should_work_with_initial_option(browser, server):
+async def test_offline_should_work_with_initial_option(
+    browser: Browser,
+    server: Server,
+    browser_name: str,
+) -> None:
     context = await browser.new_context(offline=True)
     page = await context.new_page()
+    frame_navigated_task = asyncio.create_task(page.wait_for_event("framenavigated"))
     with pytest.raises(Error) as exc_info:
         await page.goto(server.EMPTY_PAGE)
+    if browser_name == "firefox":
+        await frame_navigated_task
     assert exc_info.value
     await context.set_offline(False)
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.status == 200
     await context.close()
 
 
-async def test_offline_should_emulate_navigator_online(context, server):
+async def test_offline_should_emulate_navigator_online(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     assert await page.evaluate("window.navigator.onLine")
     await context.set_offline(True)
@@ -594,7 +655,9 @@ async def test_offline_should_emulate_navigator_online(context, server):
     assert await page.evaluate("window.navigator.onLine")
 
 
-async def test_page_event_should_have_url(context, server):
+async def test_page_event_should_have_url(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     async with context.expect_page() as other_page_info:
         await page.evaluate("url => window.open(url)", server.EMPTY_PAGE)
@@ -602,7 +665,9 @@ async def test_page_event_should_have_url(context, server):
     assert other_page.url == server.EMPTY_PAGE
 
 
-async def test_page_event_should_have_url_after_domcontentloaded(context, server):
+async def test_page_event_should_have_url_after_domcontentloaded(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     async with context.expect_page() as other_page_info:
         await page.evaluate("url => window.open(url)", server.EMPTY_PAGE)
@@ -612,8 +677,8 @@ async def test_page_event_should_have_url_after_domcontentloaded(context, server
 
 
 async def test_page_event_should_have_about_blank_url_with_domcontentloaded(
-    context, server
-):
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     async with context.expect_page() as other_page_info:
         await page.evaluate("url => window.open(url)", "about:blank")
@@ -623,8 +688,8 @@ async def test_page_event_should_have_about_blank_url_with_domcontentloaded(
 
 
 async def test_page_event_should_have_about_blank_for_empty_url_with_domcontentloaded(
-    context, server
-):
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     async with context.expect_page() as other_page_info:
         await page.evaluate("window.open()")
@@ -634,15 +699,15 @@ async def test_page_event_should_have_about_blank_for_empty_url_with_domcontentl
 
 
 async def test_page_event_should_report_when_a_new_page_is_created_and_closed(
-    context, server
-):
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
-    [other_page, _] = await asyncio.gather(
-        context.wait_for_event("page"),
-        page.evaluate(
+    async with context.expect_page() as page_info:
+        await page.evaluate(
             "url => window.open(url)", server.CROSS_PROCESS_PREFIX + "/empty.html"
-        ),
-    )
+        )
+    other_page = await page_info.value
+
     # The url is about:blank in FF when 'page' event is fired.
     assert server.CROSS_PROCESS_PREFIX in other_page.url
     assert await other_page.evaluate("['Hello', 'world'].join(' ')") == "Hello world"
@@ -653,7 +718,7 @@ async def test_page_event_should_report_when_a_new_page_is_created_and_closed(
     assert other_page in all_pages
 
     close_event_received = []
-    other_page.once("close", lambda: close_event_received.append(True))
+    other_page.once("close", lambda _: close_event_received.append(True))
     await other_page.close()
     assert close_event_received == [True]
 
@@ -662,62 +727,41 @@ async def test_page_event_should_report_when_a_new_page_is_created_and_closed(
     assert other_page not in all_pages
 
 
-async def test_page_event_should_report_initialized_pages(context, server):
-    page_event_promise = asyncio.create_task(context.wait_for_event("page"))
-    asyncio.create_task(context.new_page())
-    newPage = await page_event_promise
-    assert newPage.url == "about:blank"
+async def test_page_event_should_report_initialized_pages(
+    context: BrowserContext, server: Server
+) -> None:
+    async with context.expect_page() as page_info:
+        await context.new_page()
+    new_page = await page_info.value
+    assert new_page.url == "about:blank"
 
-    popup_event_promise = asyncio.create_task(context.wait_for_event("page"))
-    evaluate_promise = asyncio.create_task(
-        newPage.evaluate("window.open('about:blank')")
-    )
-    popup = await popup_event_promise
+    async with context.expect_page() as popup_info:
+        await new_page.evaluate("window.open('about:blank')")
+    popup = await popup_info.value
     assert popup.url == "about:blank"
-    await evaluate_promise
 
 
-# TODO: fix the server to issue callbacks on the Playwright loop
-# async def test_page_event_should_not_crash_while_redirecting_of_original_request_was_missed(
-#     context, server
-# ):
-#     page = await context.new_page()
-#     requests = []
-#     server.set_route("/one-style.css", lambda request: requests.append(request))
-#     # Open a new page. Use window.open to connect to the page later.
-
-#     [new_page, _, _] = await asyncio.gather(
-#         context.wait_for_event("page"),
-#         page.evaluate("url => window.open(url)", server.PREFIX + "/one-style.html"),
-#         server.wait_for_request("/one-style.css")
-#     )
-#     # Issue a redirect.
-#     requests[0].setResponseCode(302)
-#     requests[0].setHeader("location", "/injectedstyle.css")
-#     requests[0].finish()
-
-#     await new_page.wait_for_load_state("domcontentloaded")
-#     assert new_page.url == server.PREFIX + "/one-style.html"
-
-
-async def test_page_event_should_have_an_opener(context, server):
+async def test_page_event_should_have_an_opener(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
-    [popup, _] = await asyncio.gather(
-        context.wait_for_event("page"),
-        page.goto(server.PREFIX + "/popup/window-open.html"),
-    )
+    async with context.expect_page() as page_info:
+        await page.goto(server.PREFIX + "/popup/window-open.html")
+    popup = await page_info.value
     assert popup.url == server.PREFIX + "/popup/popup.html"
     assert await popup.opener() == page
     assert await page.opener() is None
 
 
-async def test_page_event_should_fire_page_lifecycle_events(context, server):
-    events = []
+async def test_page_event_should_fire_page_lifecycle_events(
+    context: BrowserContext, server: Server
+) -> None:
+    events: List[str] = []
 
-    def handle_page(page):
+    def handle_page(page: Page) -> None:
         events.append("CREATED: " + page.url)
-        page.on("close", lambda: events.append("DESTROYED: " + page.url))
+        page.on("close", lambda _: events.append("DESTROYED: " + page.url))
 
     context.on("page", handle_page)
 
@@ -728,26 +772,53 @@ def handle_page(page):
 
 
 @pytest.mark.skip_browser("webkit")
-async def test_page_event_should_work_with_shift_clicking(context, server):
+async def test_page_event_should_work_with_shift_clicking(
+    context: BrowserContext, server: Server
+) -> None:
     # WebKit: Shift+Click does not open a new window.
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
     await page.set_content('<a href="/one-style.html">yo</a>')
-    [popup, _] = await asyncio.gather(
-        context.wait_for_event("page"), page.click("a", modifiers=["Shift"])
-    )
+    async with context.expect_page() as page_info:
+        await page.click("a", modifiers=["Shift"])
+    popup = await page_info.value
     assert await popup.opener() is None
 
 
 @pytest.mark.only_browser("chromium")
-async def test_page_event_should_work_with_ctrl_clicking(context, server, is_mac):
+async def test_page_event_should_work_with_ctrl_clicking(
+    context: BrowserContext, server: Server
+) -> None:
     # Firefox: reports an opener in this case.
     # WebKit: Ctrl+Click does not open a new tab.
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
     await page.set_content('<a href="/one-style.html">yo</a>')
-    [popup, _] = await asyncio.gather(
-        context.wait_for_event("page"),
-        page.click("a", modifiers=["Meta" if is_mac else "Control"]),
-    )
+    async with context.expect_page() as popup_info:
+        await page.click("a", modifiers=["ControlOrMeta"])
+    popup = await popup_info.value
     assert await popup.opener() is None
+
+
+async def test_strict_selectors_on_context(browser: Browser, server: Server) -> None:
+    context = await browser.new_context(strict_selectors=True)
+    page = await context.new_page()
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content(
+        """
+        <button>Hello</button>
+        <button>Hello</button>
+    """
+    )
+    with pytest.raises(Error):
+        await page.text_content("button")
+    with pytest.raises(Error):
+        await page.query_selector("button")
+    await context.close()
+
+
+async def test_should_support_forced_colors(browser: Browser) -> None:
+    context = await browser.new_context(forced_colors="active")
+    page = await context.new_page()
+    assert await page.evaluate("matchMedia('(forced-colors: active)').matches")
+    assert not await page.evaluate("matchMedia('(forced-colors: none)').matches")
diff --git a/tests/async/test_browsercontext_add_cookies.py b/tests/async/test_browsercontext_add_cookies.py
index 1fe64309c..185a758b0 100644
--- a/tests/async/test_browsercontext_add_cookies.py
+++ b/tests/async/test_browsercontext_add_cookies.py
@@ -14,13 +14,16 @@
 
 import asyncio
 import datetime
+from typing import Callable, List
 
 import pytest
 
-from playwright.async_api import Error
+from playwright.async_api import Browser, BrowserContext, Error, Page
+from tests.server import Server, TestServerRequest
+from tests.utils import must
 
 
-async def test_should_work(context, page, server):
+async def test_should_work(context: BrowserContext, page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     await context.add_cookies(
         [{"url": server.EMPTY_PAGE, "name": "password", "value": "123456"}]
@@ -28,7 +31,9 @@ async def test_should_work(context, page, server):
     assert await page.evaluate("() => document.cookie") == "password=123456"
 
 
-async def test_should_roundtrip_cookie(context, page, server):
+async def test_should_roundtrip_cookie(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     # @see https://en.wikipedia.org/wiki/Year_2038_problem
     date = int(datetime.datetime(2038, 1, 1).timestamp() * 1000)
@@ -44,15 +49,18 @@ async def test_should_roundtrip_cookie(context, page, server):
     cookies = await context.cookies()
     await context.clear_cookies()
     assert await context.cookies() == []
-    await context.add_cookies(cookies)
+    # TODO: We are waiting for PEP705 so SetCookieParam can be readonly and matches the Cookie type.
+    await context.add_cookies(cookies)  # type: ignore
     assert await context.cookies() == cookies
 
 
-async def test_should_send_cookie_header(server, context):
-    cookie = []
+async def test_should_send_cookie_header(
+    server: Server, context: BrowserContext
+) -> None:
+    cookie: List[str] = []
 
-    def handler(request):
-        cookie.extend(request.requestHeaders.getRawHeaders("cookie"))
+    def handler(request: TestServerRequest) -> None:
+        cookie.extend(must(request.requestHeaders.getRawHeaders("cookie")))
         request.finish()
 
     server.set_route("/empty.html", handler)
@@ -64,7 +72,9 @@ def handler(request):
     assert cookie == ["cookie=value"]
 
 
-async def test_should_isolate_cookies_in_browser_contexts(context, server, browser):
+async def test_should_isolate_cookies_in_browser_contexts(
+    context: BrowserContext, server: Server, browser: Browser
+) -> None:
     another_context = await browser.new_context()
     await context.add_cookies(
         [{"url": server.EMPTY_PAGE, "name": "isolatecookie", "value": "page1value"}]
@@ -84,7 +94,9 @@ async def test_should_isolate_cookies_in_browser_contexts(context, server, brows
     await another_context.close()
 
 
-async def test_should_isolate_session_cookies(context, server, browser):
+async def test_should_isolate_session_cookies(
+    context: BrowserContext, server: Server, browser: Browser
+) -> None:
     server.set_route(
         "/setcookie.html",
         lambda r: (
@@ -110,7 +122,9 @@ async def test_should_isolate_session_cookies(context, server, browser):
     await context_b.close()
 
 
-async def test_should_isolate_persistent_cookies(context, server, browser):
+async def test_should_isolate_persistent_cookies(
+    context: BrowserContext, server: Server, browser: Browser
+) -> None:
     server.set_route(
         "/setcookie.html",
         lambda r: (
@@ -136,10 +150,12 @@ async def test_should_isolate_persistent_cookies(context, server, browser):
     await context_2.close()
 
 
-async def test_should_isolate_send_cookie_header(server, context, browser):
-    cookie = []
+async def test_should_isolate_send_cookie_header(
+    server: Server, context: BrowserContext, browser: Browser
+) -> None:
+    cookie: List[str] = []
 
-    def handler(request):
+    def handler(request: TestServerRequest) -> None:
         cookie.extend(request.requestHeaders.getRawHeaders("cookie") or [])
         request.finish()
 
@@ -161,7 +177,9 @@ def handler(request):
     await context_2.close()
 
 
-async def test_should_isolate_cookies_between_launches(browser_factory, server):
+async def test_should_isolate_cookies_between_launches(
+    browser_factory: Callable[..., "asyncio.Future[Browser]"], server: Server
+) -> None:
     browser_1 = await browser_factory()
     context_1 = await browser_1.new_context()
     await context_1.add_cookies(
@@ -183,7 +201,9 @@ async def test_should_isolate_cookies_between_launches(browser_factory, server):
     await browser_2.close()
 
 
-async def test_should_set_multiple_cookies(context, page, server):
+async def test_should_set_multiple_cookies(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await context.add_cookies(
         [
@@ -202,7 +222,9 @@ async def test_should_set_multiple_cookies(context, page, server):
     )
 
 
-async def test_should_have_expires_set_to_neg_1_for_session_cookies(context, server):
+async def test_should_have_expires_set_to_neg_1_for_session_cookies(
+    context: BrowserContext, server: Server
+) -> None:
     await context.add_cookies(
         [{"url": server.EMPTY_PAGE, "name": "expires", "value": "123456"}]
     )
@@ -210,7 +232,11 @@ async def test_should_have_expires_set_to_neg_1_for_session_cookies(context, ser
     assert cookies[0]["expires"] == -1
 
 
-async def test_should_set_cookie_with_reasonable_defaults(context, server):
+async def test_should_set_cookie_with_reasonable_defaults(
+    context: BrowserContext,
+    server: Server,
+    default_same_site_cookie_value: str,
+) -> None:
     await context.add_cookies(
         [{"url": server.EMPTY_PAGE, "name": "defaults", "value": "123456"}]
     )
@@ -225,12 +251,17 @@ async def test_should_set_cookie_with_reasonable_defaults(context, server):
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
 
-async def test_should_set_a_cookie_with_a_path(context, page, server):
+async def test_should_set_a_cookie_with_a_path(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    default_same_site_cookie_value: str,
+) -> None:
     await page.goto(server.PREFIX + "/grid.html")
     await context.add_cookies(
         [
@@ -251,7 +282,7 @@ async def test_should_set_a_cookie_with_a_path(context, page, server):
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
     assert await page.evaluate("document.cookie") == "gridcookie=GRID"
@@ -261,7 +292,9 @@ async def test_should_set_a_cookie_with_a_path(context, page, server):
     assert await page.evaluate("document.cookie") == "gridcookie=GRID"
 
 
-async def test_should_not_set_a_cookie_with_blank_page_url(context, server):
+async def test_should_not_set_a_cookie_with_blank_page_url(
+    context: BrowserContext, server: Server
+) -> None:
     with pytest.raises(Error) as exc_info:
         await context.add_cookies(
             [
@@ -275,7 +308,9 @@ async def test_should_not_set_a_cookie_with_blank_page_url(context, server):
     )
 
 
-async def test_should_not_set_a_cookie_on_a_data_url_page(context):
+async def test_should_not_set_a_cookie_on_a_data_url_page(
+    context: BrowserContext,
+) -> None:
     with pytest.raises(Error) as exc_info:
         await context.add_cookies(
             [
@@ -292,8 +327,8 @@ async def test_should_not_set_a_cookie_on_a_data_url_page(context):
 
 
 async def test_should_default_to_setting_secure_cookie_for_https_websites(
-    context, page, server
-):
+    context: BrowserContext, page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     SECURE_URL = "https://example.com"
     await context.add_cookies([{"url": SECURE_URL, "name": "foo", "value": "bar"}])
@@ -302,8 +337,8 @@ async def test_should_default_to_setting_secure_cookie_for_https_websites(
 
 
 async def test_should_be_able_to_set_unsecure_cookie_for_http_website(
-    context, page, server
-):
+    context: BrowserContext, page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     HTTP_URL = "http://example.com"
     await context.add_cookies([{"url": HTTP_URL, "name": "foo", "value": "bar"}])
@@ -311,7 +346,12 @@ async def test_should_be_able_to_set_unsecure_cookie_for_http_website(
     assert not cookie["secure"]
 
 
-async def test_should_set_a_cookie_on_a_different_domain(context, page, server):
+async def test_should_set_a_cookie_on_a_different_domain(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    default_same_site_cookie_value: str,
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await context.add_cookies(
         [{"url": "https://www.example.com", "name": "example-cookie", "value": "best"}]
@@ -326,12 +366,14 @@ async def test_should_set_a_cookie_on_a_different_domain(context, page, server):
             "expires": -1,
             "httpOnly": False,
             "secure": True,
-            "sameSite": "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
 
-async def test_should_set_cookies_for_a_frame(context, page, server):
+async def test_should_set_cookies_for_a_frame(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await context.add_cookies(
         [{"url": server.PREFIX, "name": "frame-cookie", "value": "value"}]
@@ -353,8 +395,12 @@ async def test_should_set_cookies_for_a_frame(context, page, server):
 
 
 async def test_should_not_block_third_party_cookies(
-    context, page, server, is_chromium, is_firefox
-):
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    is_chromium: bool,
+    is_firefox: bool,
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.evaluate(
         """src => {
@@ -370,7 +416,7 @@ async def test_should_not_block_third_party_cookies(
     )
     await page.frames[1].evaluate("document.cookie = 'username=John Doe'")
     await page.wait_for_timeout(2000)
-    allows_third_party = is_chromium or is_firefox
+    allows_third_party = is_firefox
     cookies = await context.cookies(server.CROSS_PROCESS_PREFIX + "/grid.html")
 
     if allows_third_party:
@@ -381,7 +427,7 @@ async def test_should_not_block_third_party_cookies(
                 "httpOnly": False,
                 "name": "username",
                 "path": "/",
-                "sameSite": "None",
+                "sameSite": "Lax" if is_chromium else "None",
                 "secure": False,
                 "value": "John Doe",
             }
diff --git a/tests/async/test_browsercontext_clearcookies.py b/tests/async/test_browsercontext_clearcookies.py
index 27e33126b..336c99718 100644
--- a/tests/async/test_browsercontext_clearcookies.py
+++ b/tests/async/test_browsercontext_clearcookies.py
@@ -12,8 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import re
+from urllib.parse import urlparse
 
-async def test_should_clear_cookies(context, page, server):
+from playwright.async_api import Browser, BrowserContext, Page
+from tests.server import Server
+
+
+async def test_should_clear_cookies(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await context.add_cookies(
         [{"url": server.EMPTY_PAGE, "name": "cookie1", "value": "1"}]
@@ -25,7 +33,9 @@ async def test_should_clear_cookies(context, page, server):
     assert await page.evaluate("document.cookie") == ""
 
 
-async def test_should_isolate_cookies_when_clearing(context, server, browser):
+async def test_should_isolate_cookies_when_clearing(
+    context: BrowserContext, server: Server, browser: Browser
+) -> None:
     another_context = await browser.new_context()
     await context.add_cookies(
         [{"url": server.EMPTY_PAGE, "name": "page1cookie", "value": "page1value"}]
@@ -45,3 +55,144 @@ async def test_should_isolate_cookies_when_clearing(context, server, browser):
     assert len(await context.cookies()) == 0
     assert len(await another_context.cookies()) == 0
     await another_context.close()
+
+
+async def test_should_remove_cookies_by_name(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    await context.add_cookies(
+        [
+            {
+                "name": "cookie1",
+                "value": "1",
+                "domain": urlparse(server.PREFIX).hostname,
+                "path": "/",
+            },
+            {
+                "name": "cookie2",
+                "value": "2",
+                "domain": urlparse(server.PREFIX).hostname,
+                "path": "/",
+            },
+        ]
+    )
+    await page.goto(server.PREFIX)
+    assert await page.evaluate("document.cookie") == "cookie1=1; cookie2=2"
+    await context.clear_cookies(name="cookie1")
+    assert await page.evaluate("document.cookie") == "cookie2=2"
+
+
+async def test_should_remove_cookies_by_name_regex(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    await context.add_cookies(
+        [
+            {
+                "name": "cookie1",
+                "value": "1",
+                "domain": urlparse(server.PREFIX).hostname,
+                "path": "/",
+            },
+            {
+                "name": "cookie2",
+                "value": "2",
+                "domain": urlparse(server.PREFIX).hostname,
+                "path": "/",
+            },
+        ]
+    )
+    await page.goto(server.PREFIX)
+    assert await page.evaluate("document.cookie") == "cookie1=1; cookie2=2"
+    await context.clear_cookies(name=re.compile("coo.*1"))
+    assert await page.evaluate("document.cookie") == "cookie2=2"
+
+
+async def test_should_remove_cookies_by_domain(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    await context.add_cookies(
+        [
+            {
+                "name": "cookie1",
+                "value": "1",
+                "domain": urlparse(server.PREFIX).hostname,
+                "path": "/",
+            },
+            {
+                "name": "cookie2",
+                "value": "2",
+                "domain": urlparse(server.CROSS_PROCESS_PREFIX).hostname,
+                "path": "/",
+            },
+        ]
+    )
+    await page.goto(server.PREFIX)
+    assert await page.evaluate("document.cookie") == "cookie1=1"
+    await page.goto(server.CROSS_PROCESS_PREFIX)
+    assert await page.evaluate("document.cookie") == "cookie2=2"
+    await context.clear_cookies(domain=urlparse(server.CROSS_PROCESS_PREFIX).hostname)
+    assert await page.evaluate("document.cookie") == ""
+    await page.goto(server.PREFIX)
+    assert await page.evaluate("document.cookie") == "cookie1=1"
+
+
+async def test_should_remove_cookies_by_path(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    await context.add_cookies(
+        [
+            {
+                "name": "cookie1",
+                "value": "1",
+                "domain": urlparse(server.PREFIX).hostname,
+                "path": "/api/v1",
+            },
+            {
+                "name": "cookie2",
+                "value": "2",
+                "domain": urlparse(server.PREFIX).hostname,
+                "path": "/api/v2",
+            },
+            {
+                "name": "cookie3",
+                "value": "3",
+                "domain": urlparse(server.PREFIX).hostname,
+                "path": "/",
+            },
+        ]
+    )
+    await page.goto(server.PREFIX + "/api/v1")
+    assert await page.evaluate("document.cookie") == "cookie1=1; cookie3=3"
+    await context.clear_cookies(path="/api/v1")
+    assert await page.evaluate("document.cookie") == "cookie3=3"
+    await page.goto(server.PREFIX + "/api/v2")
+    assert await page.evaluate("document.cookie") == "cookie2=2; cookie3=3"
+    await page.goto(server.PREFIX + "/")
+    assert await page.evaluate("document.cookie") == "cookie3=3"
+
+
+async def test_should_remove_cookies_by_name_and_domain(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    await context.add_cookies(
+        [
+            {
+                "name": "cookie1",
+                "value": "1",
+                "domain": urlparse(server.PREFIX).hostname,
+                "path": "/",
+            },
+            {
+                "name": "cookie1",
+                "value": "1",
+                "domain": urlparse(server.CROSS_PROCESS_PREFIX).hostname,
+                "path": "/",
+            },
+        ]
+    )
+    await page.goto(server.PREFIX)
+    assert await page.evaluate("document.cookie") == "cookie1=1"
+    await context.clear_cookies(name="cookie1", domain=urlparse(server.PREFIX).hostname)
+    assert await page.evaluate("document.cookie") == ""
+    await page.goto(server.CROSS_PROCESS_PREFIX)
+    assert await page.evaluate("document.cookie") == "cookie1=1"
diff --git a/tests/async/test_browsercontext_client_certificates.py b/tests/async/test_browsercontext_client_certificates.py
new file mode 100644
index 000000000..9578a69f7
--- /dev/null
+++ b/tests/async/test_browsercontext_client_certificates.py
@@ -0,0 +1,268 @@
+# 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 sys
+import threading
+from pathlib import Path
+from typing import Dict, Generator, Optional, cast
+
+import OpenSSL.crypto
+import OpenSSL.SSL
+import pytest
+from twisted.internet import reactor as _twisted_reactor
+from twisted.internet import ssl
+from twisted.internet.selectreactor import SelectReactor
+from twisted.web import resource, server
+from twisted.web.http import Request
+
+from playwright.async_api import Browser, BrowserType, Playwright, expect
+
+ssl.optionsForClientTLS
+reactor = cast(SelectReactor, _twisted_reactor)
+
+
+@pytest.fixture(scope="function", autouse=True)
+def _skip_webkit_darwin(browser_name: str) -> None:
+    if browser_name == "webkit" and sys.platform == "darwin":
+        pytest.skip("WebKit does not proxy localhost on macOS")
+
+
+class HttpsResource(resource.Resource):
+    serverCertificate: ssl.PrivateCertificate
+    isLeaf = True
+
+    def _verify_cert_chain(self, cert: Optional[OpenSSL.crypto.X509]) -> bool:
+        if not cert:
+            return False
+        store = OpenSSL.crypto.X509Store()
+        store.add_cert(self.serverCertificate.original)
+        store_ctx = OpenSSL.crypto.X509StoreContext(store, cert)
+        try:
+            store_ctx.verify_certificate()
+            return True
+        except OpenSSL.crypto.X509StoreContextError:
+            return False
+
+    def render_GET(self, request: Request) -> bytes:
+        tls_socket: OpenSSL.SSL.Connection = request.transport.getHandle()  # type: ignore
+        cert = tls_socket.get_peer_certificate()
+        parts = []
+
+        if self._verify_cert_chain(cert):
+            request.setResponseCode(200)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": f"Hello {cert.get_subject().CN}, your certificate was issued by {cert.get_issuer().CN}!",  # type: ignore
+                }
+            )
+        elif cert and cert.get_subject():
+            request.setResponseCode(403)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": f"Sorry {cert.get_subject().CN}, certificates from {cert.get_issuer().CN} are not welcome here.",
+                }
+            )
+        else:
+            request.setResponseCode(401)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": "Sorry, but you need to provide a client certificate to continue.",
+                }
+            )
+        return b"".join(
+            [
+                f'<div data-testid="{part["key"]}">{part["value"]}</div>'.encode()
+                for part in parts
+            ]
+        )
+
+
+@pytest.fixture(scope="session", autouse=True)
+def _client_certificate_server(assetdir: Path) -> Generator[None, None, None]:
+    certAuthCert = ssl.Certificate.loadPEM(
+        (assetdir / "client-certificates/server/server_cert.pem").read_text()
+    )
+    serverCert = ssl.PrivateCertificate.loadPEM(
+        (assetdir / "client-certificates/server/server_key.pem").read_text()
+        + (assetdir / "client-certificates/server/server_cert.pem").read_text()
+    )
+
+    contextFactory = serverCert.options(certAuthCert)
+    contextFactory.requireCertificate = False
+    resource = HttpsResource()
+    resource.serverCertificate = serverCert
+    site = server.Site(resource)
+
+    def _run() -> None:
+        reactor.listenSSL(8000, site, contextFactory)
+
+    thread = threading.Thread(target=_run)
+    thread.start()
+    yield
+    thread.join()
+
+
+async def test_should_throw_with_untrusted_client_certs(
+    playwright: Playwright, assetdir: Path
+) -> None:
+    serverURL = "https://localhost:8000/"
+    request = await playwright.request.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": serverURL,
+                "certPath": assetdir
+                / "client-certificates/client/self-signed/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/self-signed/key.pem",
+            }
+        ],
+    )
+    with pytest.raises(Exception, match="alert unknown ca"):
+        await request.get(serverURL)
+    await request.dispose()
+
+
+async def test_should_work_with_new_context(browser: Browser, assetdir: Path) -> None:
+    context = await browser.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    page = await context.new_page()
+    await page.goto("https://localhost:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    await page.goto("https://127.0.0.1:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+
+    response = await page.context.request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in await response.text()
+    )
+    response = await page.context.request.get("https://127.0.0.1:8000")
+    assert (
+        "Hello Alice, your certificate was issued by localhost!"
+        in await response.text()
+    )
+    await context.close()
+
+
+async def test_should_work_with_new_context_passing_as_content(
+    browser: Browser, assetdir: Path
+) -> None:
+    context = await browser.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "cert": (
+                    assetdir / "client-certificates/client/trusted/cert.pem"
+                ).read_bytes(),
+                "key": (
+                    assetdir / "client-certificates/client/trusted/key.pem"
+                ).read_bytes(),
+            }
+        ],
+    )
+    page = await context.new_page()
+    await page.goto("https://localhost:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    await page.goto("https://127.0.0.1:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+
+    response = await page.context.request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in await response.text()
+    )
+    response = await page.context.request.get("https://127.0.0.1:8000")
+    assert (
+        "Hello Alice, your certificate was issued by localhost!"
+        in await response.text()
+    )
+    await context.close()
+
+
+async def test_should_work_with_new_persistent_context(
+    browser_type: BrowserType, assetdir: Path, launch_arguments: Dict
+) -> None:
+    context = await browser_type.launch_persistent_context(
+        "",
+        **launch_arguments,
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    page = await context.new_page()
+    await page.goto("https://localhost:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    await page.goto("https://127.0.0.1:8000")
+    await expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+    await context.close()
+
+
+async def test_should_work_with_global_api_request_context(
+    playwright: Playwright, assetdir: Path
+) -> None:
+    request = await playwright.request.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    response = await request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in await response.text()
+    )
+    response = await request.get("https://127.0.0.1:8000")
+    assert (
+        "Hello Alice, your certificate was issued by localhost!"
+        in await response.text()
+    )
+    await request.dispose()
diff --git a/tests/async/test_browsercontext_cookies.py b/tests/async/test_browsercontext_cookies.py
index edd4cc780..087d00613 100644
--- a/tests/async/test_browsercontext_cookies.py
+++ b/tests/async/test_browsercontext_cookies.py
@@ -16,12 +16,22 @@
 
 import pytest
 
+from playwright.async_api import BrowserContext, Page
+from tests.server import Server
 
-async def test_should_return_no_cookies_in_pristine_browser_context(context):
+
+async def test_should_return_no_cookies_in_pristine_browser_context(
+    context: BrowserContext,
+) -> None:
     assert await context.cookies() == []
 
 
-async def test_should_get_a_cookie(context, page, server, is_firefox):
+async def test_should_get_a_cookie(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    default_same_site_cookie_value: str,
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     document_cookie = await page.evaluate(
         """() => {
@@ -39,12 +49,17 @@ async def test_should_get_a_cookie(context, page, server, is_firefox):
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
 
-async def test_should_get_a_non_session_cookie(context, page, server, is_firefox):
+async def test_should_get_a_non_session_cookie(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    default_same_site_cookie_value: str,
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     # @see https://en.wikipedia.org/wiki/Year_2038_problem
     date = int(datetime.datetime(2038, 1, 1).timestamp() * 1000)
@@ -57,21 +72,33 @@ async def test_should_get_a_non_session_cookie(context, page, server, is_firefox
         date,
     )
     assert document_cookie == "username=John Doe"
-    assert await context.cookies() == [
+    cookies = await context.cookies()
+    expires = cookies[0]["expires"]
+    del cookies[0]["expires"]
+    # Browsers start to cap cookies with 400 days max expires value.
+    # See https://github.com/httpwg/http-extensions/pull/1732
+    # Chromium patch: https://chromium.googlesource.com/chromium/src/+/aaa5d2b55478eac2ee642653dcd77a50ac3faff6
+    # We want to make sure that expires date is at least 400 days in future.
+    # We use 355 to prevent flakes and not think about timezones!
+    assert datetime.datetime.fromtimestamp(
+        expires
+    ) - datetime.datetime.now() > datetime.timedelta(days=355)
+    assert cookies == [
         {
             "name": "username",
             "value": "John Doe",
             "domain": "localhost",
             "path": "/",
-            "expires": date / 1000,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
 
-async def test_should_properly_report_httpOnly_cookie(context, page, server):
+async def test_should_properly_report_httpOnly_cookie(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
     server.set_route(
         "/empty.html",
         lambda r: (
@@ -87,8 +114,8 @@ async def test_should_properly_report_httpOnly_cookie(context, page, server):
 
 
 async def test_should_properly_report_strict_sameSite_cookie(
-    context, page, server, is_webkit, is_win
-):
+    context: BrowserContext, page: Page, server: Server, is_webkit: bool, is_win: bool
+) -> None:
     if is_webkit and is_win:
         pytest.skip()
 
@@ -106,8 +133,8 @@ async def test_should_properly_report_strict_sameSite_cookie(
 
 
 async def test_should_properly_report_lax_sameSite_cookie(
-    context, page, server, is_webkit, is_win
-):
+    context: BrowserContext, page: Page, server: Server, is_webkit: bool, is_win: bool
+) -> None:
     if is_webkit and is_win:
         pytest.skip()
 
@@ -124,7 +151,12 @@ async def test_should_properly_report_lax_sameSite_cookie(
     assert cookies[0]["sameSite"] == "Lax"
 
 
-async def test_should_get_multiple_cookies(context, page, server, is_firefox):
+async def test_should_get_multiple_cookies(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    default_same_site_cookie_value: str,
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     document_cookie = await page.evaluate(
         """() => {
@@ -145,7 +177,7 @@ async def test_should_get_multiple_cookies(context, page, server, is_firefox):
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "None",
+            "sameSite": default_same_site_cookie_value,
         },
         {
             "name": "username",
@@ -155,12 +187,14 @@ async def test_should_get_multiple_cookies(context, page, server, is_firefox):
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "None",
+            "sameSite": default_same_site_cookie_value,
         },
     ]
 
 
-async def test_should_get_cookies_from_multiple_urls(context):
+async def test_should_get_cookies_from_multiple_urls(
+    context: BrowserContext, default_same_site_cookie_value: str
+) -> None:
     await context.add_cookies(
         [
             {"url": "https://foo.com", "name": "doggo", "value": "woofs"},
@@ -180,7 +214,7 @@ async def test_should_get_cookies_from_multiple_urls(context):
             "expires": -1,
             "httpOnly": False,
             "secure": True,
-            "sameSite": "None",
+            "sameSite": default_same_site_cookie_value,
         },
         {
             "name": "doggo",
@@ -190,6 +224,6 @@ async def test_should_get_cookies_from_multiple_urls(context):
             "expires": -1,
             "httpOnly": False,
             "secure": True,
-            "sameSite": "None",
+            "sameSite": default_same_site_cookie_value,
         },
     ]
diff --git a/tests/async/test_browsercontext_events.py b/tests/async/test_browsercontext_events.py
new file mode 100644
index 000000000..83c485286
--- /dev/null
+++ b/tests/async/test_browsercontext_events.py
@@ -0,0 +1,320 @@
+# 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 asyncio
+from typing import Optional
+
+import pytest
+
+from playwright.async_api import BrowserContext, Page
+from tests.utils import must
+
+from ..server import Server, TestServerRequest
+
+
+async def test_console_event_should_work(page: Page) -> None:
+    [message, _] = await asyncio.gather(
+        page.context.wait_for_event("console"),
+        page.evaluate("() => console.log('hello')"),
+    )
+    assert message.text == "hello"
+    assert message.page == page
+
+
+async def test_console_event_should_work_in_popup(page: Page) -> None:
+    [message, popup, _] = await asyncio.gather(
+        page.context.wait_for_event("console"),
+        page.wait_for_event("popup"),
+        page.evaluate(
+            """() => {
+            const win = window.open('');
+            win.console.log('hello');
+        }"""
+        ),
+    )
+    assert message.text == "hello"
+    assert message.page == popup
+
+
+# console message from javascript: url is not reported at all
+@pytest.mark.skip_browser("firefox")
+async def test_console_event_should_work_in_popup_2(
+    page: Page, browser_name: str
+) -> None:
+    [message, popup, _] = await asyncio.gather(
+        page.context.wait_for_event("console", lambda msg: msg.type == "log"),
+        page.context.wait_for_event("page"),
+        page.evaluate(
+            """async () => {
+            const win = window.open('javascript:console.log("hello")');
+            await new Promise(f => setTimeout(f, 0));
+            win.close();
+        }"""
+        ),
+    )
+    assert message.text == "hello"
+    assert message.page == popup
+
+
+# console message from javascript: url is not reported at all
+@pytest.mark.skip_browser("firefox")
+async def test_console_event_should_work_in_immediately_closed_popup(
+    page: Page, browser_name: str
+) -> None:
+    [message, popup, _] = await asyncio.gather(
+        page.context.wait_for_event("console"),
+        page.wait_for_event("popup"),
+        page.evaluate(
+            """async () => {
+            const win = window.open();
+            win.console.log('hello');
+            win.close();
+        }"""
+        ),
+    )
+    assert message.text == "hello"
+    assert message.page == popup
+
+
+async def test_dialog_event_should_work1(page: Page) -> None:
+    prompt_task: Optional[asyncio.Future[str]] = None
+
+    async def open_dialog() -> None:
+        nonlocal prompt_task
+        prompt_task = asyncio.create_task(page.evaluate("() => prompt('hey?')"))
+
+    [dialog1, dialog2, _] = await asyncio.gather(
+        page.context.wait_for_event("dialog"),
+        page.wait_for_event("dialog"),
+        open_dialog(),
+    )
+    assert dialog1 == dialog2
+    assert dialog1.message == "hey?"
+    assert dialog1.page == page
+    await dialog1.accept("hello")
+    assert await must(prompt_task) == "hello"
+
+
+async def test_dialog_event_should_work_in_popup(page: Page) -> None:
+    prompt_task: Optional[asyncio.Future[str]] = None
+
+    async def open_dialog() -> None:
+        nonlocal prompt_task
+        prompt_task = asyncio.create_task(
+            page.evaluate("() => window.open('').prompt('hey?')")
+        )
+
+    [dialog, popup, _] = await asyncio.gather(
+        page.context.wait_for_event("dialog"),
+        page.wait_for_event("popup"),
+        open_dialog(),
+    )
+    assert dialog.message == "hey?"
+    assert dialog.page == popup
+    await dialog.accept("hello")
+    assert await must(prompt_task) == "hello"
+
+
+# console message from javascript: url is not reported at all
+@pytest.mark.skip_browser("firefox")
+async def test_dialog_event_should_work_in_popup_2(
+    page: Page, browser_name: str
+) -> None:
+    promise = asyncio.create_task(
+        page.evaluate("() => window.open('javascript:prompt(\"hey?\")')")
+    )
+    dialog = await page.context.wait_for_event("dialog")
+    assert dialog.message == "hey?"
+    assert dialog.page is None
+    await dialog.accept("hello")
+    await promise
+
+
+# console message from javascript: url is not reported at all
+@pytest.mark.skip_browser("firefox")
+async def test_dialog_event_should_work_in_immdiately_closed_popup(page: Page) -> None:
+    [message, popup, _] = await asyncio.gather(
+        page.context.wait_for_event("console"),
+        page.wait_for_event("popup"),
+        page.evaluate(
+            """() => {
+            const win = window.open();
+            win.console.log('hello');
+            win.close();
+        }"""
+        ),
+    )
+    assert message.text == "hello"
+    assert message.page == popup
+
+
+async def test_dialog_event_should_work_with_inline_script_tag(
+    page: Page, server: Server
+) -> None:
+    def handle_route(request: TestServerRequest) -> None:
+        request.setHeader("content-type", "text/html")
+        request.write(b"""<script>window.result = prompt('hey?')</script>""")
+        request.finish()
+
+    server.set_route("/popup.html", handle_route)
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<a href='popup.html' target=_blank>Click me</a>")
+
+    promise = asyncio.create_task(page.click("a"))
+    [dialog, popup] = await asyncio.gather(
+        page.context.wait_for_event("dialog"),
+        page.wait_for_event("popup"),
+    )
+
+    assert dialog.message == "hey?"
+    assert dialog.page == popup
+    await dialog.accept("hello")
+    await promise
+    assert await popup.evaluate("window.result") == "hello"
+
+
+async def test_console_event_should_work_with_context_manager(page: Page) -> None:
+    async with page.context.expect_console_message() as cm_info:
+        await page.evaluate("() => console.log('hello')")
+    message = await cm_info.value
+    assert message.text == "hello"
+    assert message.page == page
+
+
+async def test_page_error_event_should_work(page: Page) -> None:
+    async with page.context.expect_event("weberror") as page_error_info:
+        await page.set_content('<script>throw new Error("boom")</script>')
+    page_error = await page_error_info.value
+    assert page_error.page == page
+    assert page_error.error.stack and "boom" in page_error.error.stack
+
+
+async def test_weberror_event_should_work(context: BrowserContext, page: Page) -> None:
+    async with context.expect_event("weberror") as error_info:
+        await page.goto('data:text/html,<script>throw new Error("Test")</script>')
+    error = await error_info.value
+    assert error.page == page
+    assert error.error.message == "Test"
+
+
+async def test_weberror_event_should_include_location(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    def handle_error_js(request: TestServerRequest) -> None:
+        request.setHeader("content-type", "application/javascript")
+        request.write(
+            b"""
+            function foo() {
+                throw new Error('boom');
+            }
+            foo();
+            """
+        )
+        request.finish()
+
+    def handle_error_html(request: TestServerRequest) -> None:
+        request.setHeader("content-type", "text/html")
+        request.write(b'<script src="/error.js"></script>')
+        request.finish()
+
+    server.set_route("/error.js", handle_error_js)
+    server.set_route("/error.html", handle_error_html)
+
+    async with context.expect_event("weberror") as error_info:
+        await page.goto(server.PREFIX + "/error.html")
+    web_error = await error_info.value
+    location = web_error.location
+    assert location["url"] == f"{server.PREFIX}/error.js"
+    assert location["line"] == 2
+    assert location["column"] > 0
+
+
+async def test_pageload_event_should_work(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    async with context.expect_event("pageload") as info:
+        await page.goto(server.EMPTY_PAGE)
+    event_page = await info.value
+    assert event_page == page
+
+
+async def test_framenavigated_event_should_work(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    async with context.expect_event("framenavigated") as info:
+        await page.goto(server.EMPTY_PAGE)
+    frame = await info.value
+    assert frame == page.main_frame
+    assert frame.url == server.EMPTY_PAGE
+
+
+async def test_pageclose_event_should_work(context: BrowserContext) -> None:
+    page = await context.new_page()
+    async with context.expect_event("pageclose") as info:
+        await page.close()
+    closed = await info.value
+    assert closed == page
+
+
+async def test_frameattached_event_should_work(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    async with context.expect_event("frameattached") as info:
+        await page.evaluate(
+            """() => {
+                const iframe = document.createElement('iframe');
+                iframe.src = 'about:blank';
+                document.body.appendChild(iframe);
+            }"""
+        )
+    frame = await info.value
+    assert frame.parent_frame == page.main_frame
+
+
+async def test_framedetached_event_should_work(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate(
+        """() => {
+            const iframe = document.createElement('iframe');
+            iframe.id = 'x';
+            iframe.src = 'about:blank';
+            document.body.appendChild(iframe);
+        }"""
+    )
+    await page.wait_for_selector("iframe")
+    async with context.expect_event("framedetached") as info:
+        await page.evaluate("() => document.getElementById('x').remove()")
+    frame = await info.value
+    assert frame.parent_frame == page.main_frame
+
+
+async def test_download_event_should_work(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    def handle_download(request: TestServerRequest) -> None:
+        request.setHeader("Content-Type", "application/octet-stream")
+        request.setHeader("Content-Disposition", "attachment; filename=file.txt")
+        request.write(b"Hello world")
+        request.finish()
+
+    server.set_route("/download", handle_download)
+    await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
+    async with context.expect_event("download") as info:
+        await page.click("a")
+    download = await info.value
+    assert download.suggested_filename == "file.txt"
+    assert download.page == page
diff --git a/tests/async/test_browsercontext_proxy.py b/tests/async/test_browsercontext_proxy.py
new file mode 100644
index 000000000..f511a0bee
--- /dev/null
+++ b/tests/async/test_browsercontext_proxy.py
@@ -0,0 +1,161 @@
+# 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 asyncio
+import base64
+from typing import AsyncGenerator, Awaitable, Callable
+
+import pytest
+
+from playwright.async_api import Browser, BrowserContext
+from tests.server import Server, TestServerRequest
+
+
+@pytest.fixture(scope="session")
+async def browser(
+    browser_factory: "Callable[..., asyncio.Future[Browser]]",
+) -> AsyncGenerator[Browser, None]:
+    browser = await browser_factory(proxy={"server": "dummy"})
+    yield browser
+    await browser.close()
+
+
+async def test_should_use_proxy(
+    context_factory: "Callable[..., asyncio.Future[BrowserContext]]", server: Server
+) -> None:
+    server.set_route(
+        "/target.html",
+        lambda r: (
+            r.write(b"<html><title>Served by the proxy</title></html>"),
+            r.finish(),
+        ),
+    )
+    context = await context_factory(proxy={"server": f"localhost:{server.PORT}"})
+    page = await context.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Served by the proxy"
+
+
+async def test_proxy_should_allow_none_for_optional_settings(
+    context_factory: "Callable[..., asyncio.Future[BrowserContext]]", server: Server
+) -> None:
+    server.set_route(
+        "/target.html",
+        lambda r: (
+            r.write(b"<html><title>Served by the proxy</title></html>"),
+            r.finish(),
+        ),
+    )
+    context = await context_factory(
+        proxy={
+            "server": f"localhost:{server.PORT}",
+            "username": None,
+            "password": None,
+            "bypass": None,
+        }
+    )
+    page = await context.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Served by the proxy"
+
+
+async def test_should_use_proxy_for_second_page(
+    context_factory: "Callable[..., Awaitable[BrowserContext]]", server: Server
+) -> None:
+    server.set_route(
+        "/target.html",
+        lambda r: (
+            r.write(b"<html><title>Served by the proxy</title></html>"),
+            r.finish(),
+        ),
+    )
+    context = await context_factory(proxy={"server": f"localhost:{server.PORT}"})
+
+    page1 = await context.new_page()
+    await page1.goto("http://non-existent.com/target.html")
+    assert await page1.title() == "Served by the proxy"
+
+    page2 = await context.new_page()
+    await page2.goto("http://non-existent.com/target.html")
+    assert await page2.title() == "Served by the proxy"
+
+
+async def test_should_work_with_ip_port_notion(
+    context_factory: "Callable[..., Awaitable[BrowserContext]]", server: Server
+) -> None:
+    server.set_route(
+        "/target.html",
+        lambda r: (
+            r.write(b"<html><title>Served by the proxy</title></html>"),
+            r.finish(),
+        ),
+    )
+    context = await context_factory(proxy={"server": f"127.0.0.1:{server.PORT}"})
+    page = await context.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Served by the proxy"
+
+
+async def test_should_authenticate(
+    context_factory: "Callable[..., Awaitable[BrowserContext]]", server: Server
+) -> None:
+    def handler(req: TestServerRequest) -> None:
+        auth = req.getHeader("proxy-authorization")
+        if not auth:
+            req.setHeader(
+                b"Proxy-Authenticate", b'Basic realm="Access to internal site"'
+            )
+            req.setResponseCode(407)
+        else:
+            req.write(f"<html><title>{auth}</title></html>".encode("utf-8"))
+        req.finish()
+
+    server.set_route("/target.html", handler)
+
+    context = await context_factory(
+        proxy={
+            "server": f"localhost:{server.PORT}",
+            "username": "user",
+            "password": "secret",
+        }
+    )
+    page = await context.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Basic " + base64.b64encode(b"user:secret").decode(
+        "utf-8"
+    )
+
+
+async def test_should_authenticate_with_empty_password(
+    context_factory: "Callable[..., Awaitable[BrowserContext]]", server: Server
+) -> None:
+    def handler(req: TestServerRequest) -> None:
+        auth = req.getHeader("proxy-authorization")
+        if not auth:
+            req.setHeader(
+                b"Proxy-Authenticate", b'Basic realm="Access to internal site"'
+            )
+            req.setResponseCode(407)
+        else:
+            req.write(f"<html><title>{auth}</title></html>".encode("utf-8"))
+        req.finish()
+
+    server.set_route("/target.html", handler)
+
+    context = await context_factory(
+        proxy={"server": f"localhost:{server.PORT}", "username": "user", "password": ""}
+    )
+    page = await context.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Basic " + base64.b64encode(b"user:").decode("utf-8")
diff --git a/tests/async/test_browsercontext_request_fallback.py b/tests/async/test_browsercontext_request_fallback.py
new file mode 100644
index 000000000..9abb14649
--- /dev/null
+++ b/tests/async/test_browsercontext_request_fallback.py
@@ -0,0 +1,297 @@
+# 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 asyncio
+from typing import Any, Callable, Coroutine, cast
+
+from playwright.async_api import BrowserContext, Page, Request, Route
+from tests.server import Server
+
+
+async def test_should_work(page: Page, context: BrowserContext, server: Server) -> None:
+    await context.route("**/*", lambda route: asyncio.create_task(route.fallback()))
+    await page.goto(server.EMPTY_PAGE)
+
+
+async def test_should_fall_back(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    intercepted = []
+
+    def _handler1(route: Route) -> None:
+        intercepted.append(1)
+        asyncio.create_task(route.fallback())
+
+    await context.route("**/empty.html", _handler1)
+
+    def _handler2(route: Route) -> None:
+        intercepted.append(2)
+        asyncio.create_task(route.fallback())
+
+    await context.route(
+        "**/empty.html",
+        _handler2,
+    )
+
+    def _handler3(route: Route) -> None:
+        intercepted.append(3)
+        asyncio.create_task(route.fallback())
+
+    await context.route("**/empty.html", _handler3)
+
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+async def test_should_fall_back_async_delayed(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    intercepted = []
+
+    def create_handler(i: int) -> Callable[[Route], Coroutine]:
+        async def handler(route: Route) -> None:
+            intercepted.append(i)
+            await asyncio.sleep(0.1)
+            await route.fallback()
+
+        return handler
+
+    await context.route("**/empty.html", create_handler(1))
+    await context.route("**/empty.html", create_handler(2))
+    await context.route("**/empty.html", create_handler(3))
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+async def test_should_chain_once(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await context.route(
+        "**/madeup.txt",
+        lambda route: asyncio.create_task(
+            route.fulfill(status=200, body="fulfilled one")
+        ),
+        times=1,
+    )
+    await context.route(
+        "**/madeup.txt", lambda route: asyncio.create_task(route.fallback()), times=1
+    )
+
+    resp = await page.goto(server.PREFIX + "/madeup.txt")
+    assert resp
+    body = await resp.body()
+    assert body == b"fulfilled one"
+
+
+async def test_should_fall_back_after_exception(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await context.route("**/empty.html", lambda route: route.continue_())
+
+    async def handler(route: Route) -> None:
+        try:
+            await route.fulfill(response=cast(Any, {}))
+        except Exception:
+            await route.fallback()
+
+    await context.route("**/empty.html", handler)
+
+    await page.goto(server.EMPTY_PAGE)
+
+
+async def test_should_amend_http_headers(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    values = []
+
+    async def handler(route: Route) -> None:
+        values.append(route.request.headers.get("foo"))
+        values.append(await route.request.header_value("FOO"))
+        await route.continue_()
+
+    await context.route("**/sleep.zzz", handler)
+
+    async def handler_with_header_mods(route: Route) -> None:
+        await route.fallback(headers={**route.request.headers, "FOO": "bar"})
+
+    await context.route("**/*", handler_with_header_mods)
+
+    await page.goto(server.EMPTY_PAGE)
+    with server.expect_request("/sleep.zzz") as server_request_info:
+        await page.evaluate("() => fetch('/sleep.zzz')")
+    values.append(server_request_info.value.getHeader("foo"))
+    assert values == ["bar", "bar", "bar"]
+
+
+async def test_should_delete_header_with_undefined_value(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    server.set_route(
+        "/something",
+        lambda r: (
+            r.setHeader("Acces-Control-Allow-Origin", "*"),
+            r.write(b"done"),
+            r.finish(),
+        ),
+    )
+
+    intercepted_request = []
+
+    async def capture_and_continue(route: Route, request: Request) -> None:
+        intercepted_request.append(request)
+        await route.continue_()
+
+    await context.route("**/*", capture_and_continue)
+
+    async def delete_foo_header(route: Route, request: Request) -> None:
+        headers = await request.all_headers()
+        del headers["foo"]
+        await route.fallback(headers=headers)
+
+    await context.route(server.PREFIX + "/something", delete_foo_header)
+
+    [server_req, text] = await asyncio.gather(
+        server.wait_for_request("/something"),
+        page.evaluate(
+            """
+            async url => {
+                const data = await fetch(url, {
+                    headers: {
+                    foo: 'a',
+                    bar: 'b',
+                    }
+                });
+                return data.text();
+                }
+            """,
+            server.PREFIX + "/something",
+        ),
+    )
+
+    assert text == "done"
+    assert not intercepted_request[0].headers.get("foo")
+    assert intercepted_request[0].headers.get("bar") == "b"
+    assert not server_req.getHeader("foo")
+    assert server_req.getHeader("bar") == "b"
+
+
+async def test_should_amend_method(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    method = []
+
+    def _handler1(route: Route) -> None:
+        method.append(route.request.method)
+        asyncio.create_task(route.continue_())
+
+    await context.route("**/*", _handler1)
+    await context.route(
+        "**/*", lambda route: asyncio.create_task(route.fallback(method="POST"))
+    )
+
+    [request, _] = await asyncio.gather(
+        server.wait_for_request("/sleep.zzz"),
+        page.evaluate("() => fetch('/sleep.zzz')"),
+    )
+
+    assert method == ["POST"]
+    assert request.method == b"POST"
+
+
+async def test_should_override_request_url(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    url = []
+
+    def _handler1(route: Route) -> None:
+        url.append(route.request.url)
+        asyncio.create_task(route.continue_())
+
+    await context.route(
+        "**/global-var.html",
+        _handler1,
+    )
+
+    def _handler2(route: Route) -> None:
+        asyncio.create_task(route.fallback(url=server.PREFIX + "/global-var.html"))
+
+    await context.route(
+        "**/foo",
+        _handler2,
+    )
+
+    [server_request, response, _] = await asyncio.gather(
+        server.wait_for_request("/global-var.html"),
+        page.wait_for_event("response"),
+        page.goto(server.PREFIX + "/foo"),
+    )
+
+    assert url == [server.PREFIX + "/global-var.html"]
+    assert response.url == server.PREFIX + "/global-var.html"
+    assert response.request.url == server.PREFIX + "/global-var.html"
+    assert await page.evaluate("() => window['globalVar']") == 123
+    assert server_request.uri == b"/global-var.html"
+    assert server_request.method == b"GET"
+
+
+async def test_should_amend_post_data(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    post_data = []
+
+    def _handler1(route: Route) -> None:
+        post_data.append(route.request.post_data)
+        asyncio.create_task(route.continue_())
+
+    await context.route("**/*", _handler1)
+    await context.route(
+        "**/*", lambda route: asyncio.create_task(route.fallback(post_data="doggo"))
+    )
+    [server_request, _] = await asyncio.gather(
+        server.wait_for_request("/sleep.zzz"),
+        page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })"),
+    )
+    assert post_data == ["doggo"]
+    assert server_request.post_body == b"doggo"
+
+
+async def test_should_amend_binary_post_data(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    post_data_buffer = []
+
+    def _handler1(route: Route) -> None:
+        post_data_buffer.append(route.request.post_data)
+        asyncio.create_task(route.continue_())
+
+    await context.route("**/*", _handler1)
+
+    def _handler2(route: Route) -> None:
+        asyncio.create_task(route.fallback(post_data=b"\x00\x01\x02\x03\x04"))
+
+    await context.route("**/*", _handler2)
+
+    [server_request, result] = await asyncio.gather(
+        server.wait_for_request("/sleep.zzz"),
+        page.evaluate("fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })"),
+    )
+    # FIXME: should this be bytes?
+    assert post_data_buffer == ["\x00\x01\x02\x03\x04"]
+    assert server_request.method == b"POST"
+    assert server_request.post_body == b"\x00\x01\x02\x03\x04"
diff --git a/tests/async/test_browsercontext_request_intercept.py b/tests/async/test_browsercontext_request_intercept.py
new file mode 100644
index 000000000..1b4f57322
--- /dev/null
+++ b/tests/async/test_browsercontext_request_intercept.py
@@ -0,0 +1,194 @@
+# 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 asyncio
+from pathlib import Path
+
+import pytest
+from twisted.web import http
+
+from playwright.async_api import BrowserContext, Page, Route
+from tests.server import Server
+
+
+async def test_should_fulfill_intercepted_response(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    async def handle(route: Route) -> None:
+        response = await page.request.fetch(route.request)
+        await route.fulfill(
+            response=response,
+            status=201,
+            headers={"foo": "bar"},
+            content_type="text/plain",
+            body="Yo, page!",
+        )
+
+    await context.route("**/*", handle)
+    response = await page.goto(server.PREFIX + "/empty.html")
+    assert response
+    assert response.status == 201
+    assert response.headers["foo"] == "bar"
+    assert response.headers["content-type"] == "text/plain"
+    assert await page.evaluate("() => document.body.textContent") == "Yo, page!"
+
+
+async def test_should_fulfill_response_with_empty_body(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    async def handle(route: Route) -> None:
+        response = await page.request.fetch(route.request)
+        await route.fulfill(
+            response=response, status=201, body="", headers={"content-length": "0"}
+        )
+
+    await context.route("**/*", handle)
+    response = await page.goto(server.PREFIX + "/title.html")
+    assert response
+    assert response.status == 201
+    assert await response.text() == ""
+
+
+async def test_should_override_with_defaults_when_intercepted_response_not_provided(
+    page: Page, context: BrowserContext, server: Server, browser_name: str
+) -> None:
+    def server_handler(request: http.Request) -> None:
+        request.setHeader("foo", "bar")
+        request.write("my content".encode())
+        request.finish()
+
+    server.set_route("/empty.html", server_handler)
+
+    async def handle(route: Route) -> None:
+        await page.request.fetch(route.request)
+        await route.fulfill(status=201)
+
+    await context.route("**/*", handle)
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 201
+    assert await response.text() == ""
+    if browser_name == "webkit":
+        assert response.headers == {"content-type": "text/plain"}
+    else:
+        assert response.headers == {}
+
+
+async def test_should_fulfill_with_any_response(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    def server_handler(request: http.Request) -> None:
+        request.setHeader("foo", "bar")
+        request.write("Woo-hoo".encode())
+        request.finish()
+
+    server.set_route("/sample", server_handler)
+    sample_response = await page.request.get(server.PREFIX + "/sample")
+    await context.route(
+        "**/*",
+        lambda route: route.fulfill(
+            response=sample_response, status=201, content_type="text/plain"
+        ),
+    )
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 201
+    assert await response.text() == "Woo-hoo"
+    assert response.headers["foo"] == "bar"
+
+
+async def test_should_support_fulfill_after_intercept(
+    page: Page, context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    request_future = asyncio.create_task(server.wait_for_request("/title.html"))
+
+    async def handle_route(route: Route) -> None:
+        response = await page.request.fetch(route.request)
+        await route.fulfill(response=response)
+
+    await context.route("**", handle_route)
+    response = await page.goto(server.PREFIX + "/title.html")
+    assert response
+    request = await request_future
+    assert request.uri.decode() == "/title.html"
+    original = (assetdir / "title.html").read_text()
+    assert await response.text() == original
+
+
+async def test_should_give_access_to_the_intercepted_response(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    route_task: "asyncio.Future[Route]" = asyncio.Future()
+    await context.route("**/title.html", lambda route: route_task.set_result(route))
+
+    eval_task = asyncio.create_task(
+        page.evaluate("url => fetch(url)", server.PREFIX + "/title.html")
+    )
+
+    route = await route_task
+    response = await page.request.fetch(route.request)
+
+    assert response.status == 200
+    assert response.status_text == "OK"
+    assert response.ok is True
+    assert response.url.endswith("/title.html") is True
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert list(
+        filter(
+            lambda header: header["name"].lower() == "content-type",
+            response.headers_array,
+        )
+    ) == [{"name": "Content-Type", "value": "text/html; charset=utf-8"}]
+
+    await asyncio.gather(
+        route.fulfill(response=response),
+        eval_task,
+    )
+
+
+async def test_should_give_access_to_the_intercepted_response_body(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    route_task: "asyncio.Future[Route]" = asyncio.Future()
+    await context.route("**/simple.json", lambda route: route_task.set_result(route))
+
+    eval_task = asyncio.create_task(
+        page.evaluate("url => fetch(url)", server.PREFIX + "/simple.json")
+    )
+
+    route = await route_task
+    response = await page.request.fetch(route.request)
+
+    assert await response.text() == '{"foo": "bar"}\n'
+
+    await asyncio.gather(
+        route.fulfill(response=response),
+        eval_task,
+    )
+
+
+async def test_should_show_exception_after_fulfill(page: Page, server: Server) -> None:
+    async def _handle(route: Route) -> None:
+        await route.continue_()
+        raise Exception("Exception text!?")
+
+    await page.route("*/**", _handle)
+    await page.goto(server.EMPTY_PAGE)
+    # Any next API call should throw because handler did throw during previous goto()
+    with pytest.raises(Exception, match="Exception text!?"):
+        await page.goto(server.EMPTY_PAGE)
diff --git a/tests/async/test_browsercontext_route.py b/tests/async/test_browsercontext_route.py
new file mode 100644
index 000000000..d629be467
--- /dev/null
+++ b/tests/async/test_browsercontext_route.py
@@ -0,0 +1,516 @@
+# 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 asyncio
+import re
+from typing import Awaitable, Callable, List
+
+import pytest
+
+from playwright.async_api import (
+    Browser,
+    BrowserContext,
+    Error,
+    Page,
+    Request,
+    Route,
+    expect,
+)
+from tests.server import Server, TestServerRequest
+from tests.utils import must
+
+
+async def test_route_should_intercept(context: BrowserContext, server: Server) -> None:
+    intercepted = []
+
+    def handle(route: Route, request: Request) -> None:
+        intercepted.append(True)
+        assert "empty.html" in request.url
+        assert request.headers["user-agent"]
+        assert request.method == "GET"
+        assert request.post_data is None
+        assert request.is_navigation_request()
+        assert request.resource_type == "document"
+        assert request.frame == page.main_frame
+        assert request.frame.url == "about:blank"
+        asyncio.create_task(route.continue_())
+
+    await context.route("**/empty.html", lambda route, request: handle(route, request))
+    page = await context.new_page()
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.ok
+    assert intercepted == [True]
+    await context.close()
+
+
+async def test_route_should_unroute(context: BrowserContext, server: Server) -> None:
+    page = await context.new_page()
+
+    intercepted: List[int] = []
+
+    def handler(route: Route, request: Request, ordinal: int) -> None:
+        intercepted.append(ordinal)
+        asyncio.create_task(route.continue_())
+
+    await context.route("**/*", lambda route, request: handler(route, request, 1))
+    await context.route(
+        "**/empty.html", lambda route, request: handler(route, request, 2)
+    )
+    await context.route(
+        "**/empty.html", lambda route, request: handler(route, request, 3)
+    )
+
+    def handler4(route: Route, request: Request) -> None:
+        handler(route, request, 4)
+
+    await context.route(re.compile("empty.html"), handler4)
+
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [4]
+
+    intercepted = []
+    await context.unroute(re.compile("empty.html"), handler4)
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3]
+
+    intercepted = []
+    await context.unroute("**/empty.html")
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [1]
+
+
+async def test_route_should_yield_to_page_route(
+    context: BrowserContext, server: Server
+) -> None:
+    await context.route(
+        "**/empty.html",
+        lambda route, request: asyncio.create_task(
+            route.fulfill(status=200, body="context")
+        ),
+    )
+
+    page = await context.new_page()
+    await page.route(
+        "**/empty.html",
+        lambda route, request: asyncio.create_task(
+            route.fulfill(status=200, body="page")
+        ),
+    )
+
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.ok
+    assert await response.text() == "page"
+
+
+async def test_route_should_fall_back_to_context_route(
+    context: BrowserContext, server: Server
+) -> None:
+    await context.route(
+        "**/empty.html",
+        lambda route, request: asyncio.create_task(
+            route.fulfill(status=200, body="context")
+        ),
+    )
+
+    page = await context.new_page()
+    await page.route(
+        "**/non-empty.html",
+        lambda route, request: asyncio.create_task(
+            route.fulfill(status=200, body="page")
+        ),
+    )
+
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.ok
+    assert await response.text() == "context"
+
+
+async def test_should_support_set_cookie_header(
+    context_factory: "Callable[..., Awaitable[BrowserContext]]",
+    default_same_site_cookie_value: str,
+) -> None:
+    context = await context_factory()
+    page = await context.new_page()
+    await page.route(
+        "https://example.com/",
+        lambda route: route.fulfill(
+            headers={
+                "Set-Cookie": "name=value; domain=.example.com; Path=/",
+            },
+            content_type="text/html",
+            body="done",
+        ),
+    )
+    await page.goto("https://example.com")
+    cookies = await context.cookies()
+    assert len(cookies) == 1
+    assert cookies[0] == {
+        "sameSite": default_same_site_cookie_value,
+        "name": "name",
+        "value": "value",
+        "domain": ".example.com",
+        "path": "/",
+        "expires": -1,
+        "httpOnly": False,
+        "secure": False,
+    }
+
+
+@pytest.mark.skip_browser("webkit")
+async def test_should_ignore_secure_set_cookie_header_for_insecure_request(
+    context_factory: "Callable[..., Awaitable[BrowserContext]]",
+) -> None:
+    context = await context_factory()
+    page = await context.new_page()
+    await page.route(
+        "http://example.com/",
+        lambda route: route.fulfill(
+            headers={
+                "Set-Cookie": "name=value; domain=.example.com; Path=/; Secure",
+            },
+            content_type="text/html",
+            body="done",
+        ),
+    )
+    await page.goto("http://example.com")
+    cookies = await context.cookies()
+    assert len(cookies) == 0
+
+
+async def test_should_use_set_cookie_header_in_future_requests(
+    context_factory: "Callable[..., Awaitable[BrowserContext]]",
+    server: Server,
+    default_same_site_cookie_value: str,
+) -> None:
+    context = await context_factory()
+    page = await context.new_page()
+
+    await page.route(
+        server.EMPTY_PAGE,
+        lambda route: route.fulfill(
+            headers={
+                "Set-Cookie": "name=value",
+            },
+            content_type="text/html",
+            body="done",
+        ),
+    )
+    await page.goto(server.EMPTY_PAGE)
+    assert await context.cookies() == [
+        {
+            "sameSite": default_same_site_cookie_value,
+            "name": "name",
+            "value": "value",
+            "domain": "localhost",
+            "path": "/",
+            "expires": -1,
+            "httpOnly": False,
+            "secure": False,
+        }
+    ]
+
+    cookie = ""
+
+    def _handle_request(request: TestServerRequest) -> None:
+        nonlocal cookie
+        cookie = must(request.getHeader("cookie"))
+        request.finish()
+
+    server.set_route("/foo.html", _handle_request)
+    await page.goto(server.PREFIX + "/foo.html")
+    assert cookie == "name=value"
+
+
+async def test_should_work_with_ignore_https_errors(
+    browser: Browser, https_server: Server
+) -> None:
+    context = await browser.new_context(ignore_https_errors=True)
+    page = await context.new_page()
+
+    await page.route("**/*", lambda route: route.continue_())
+    response = await page.goto(https_server.EMPTY_PAGE)
+    assert must(response).status == 200
+    await context.close()
+
+
+async def test_should_support_the_times_parameter_with_route_matching(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    intercepted: List[int] = []
+
+    async def _handle_request(route: Route) -> None:
+        intercepted.append(1)
+        await route.continue_()
+
+    await context.route("**/empty.html", _handle_request, times=1)
+    await page.goto(server.EMPTY_PAGE)
+    await page.goto(server.EMPTY_PAGE)
+    await page.goto(server.EMPTY_PAGE)
+    assert len(intercepted) == 1
+
+
+async def test_should_work_if_handler_with_times_parameter_was_removed_from_another_handler(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    intercepted = []
+
+    async def _handler(route: Route) -> None:
+        intercepted.append("first")
+        await route.continue_()
+
+    await context.route("**/*", _handler, times=1)
+
+    async def _handler2(route: Route) -> None:
+        intercepted.append("second")
+        await context.unroute("**/*", _handler)
+        await route.fallback()
+
+    await context.route("**/*", _handler2)
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == ["second"]
+    intercepted.clear()
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == ["second"]
+
+
+async def test_should_support_async_handler_with_times(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    async def _handler(route: Route) -> None:
+        await asyncio.sleep(0.1)
+        await route.fulfill(
+            body="<html>intercepted</html>",
+            content_type="text/html",
+        )
+
+    await context.route("**/empty.html", _handler, times=1)
+    await page.goto(server.EMPTY_PAGE)
+    await expect(page.locator("body")).to_have_text("intercepted")
+    await page.goto(server.EMPTY_PAGE)
+    await expect(page.locator("body")).not_to_have_text("intercepted")
+
+
+async def test_should_override_post_body_with_empty_string(
+    context: BrowserContext, server: Server, page: Page
+) -> None:
+    await context.route(
+        "**/empty.html",
+        lambda route: route.continue_(
+            post_data="",
+        ),
+    )
+
+    req = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        page.set_content(
+            """
+            <script>
+            (async () => {
+                await fetch('%s', {
+                    method: 'POST',
+                    body: 'original',
+                });
+            })()
+            </script>
+            """
+            % server.EMPTY_PAGE
+        ),
+    )
+
+    assert req[0].post_body == b""
+
+
+async def test_should_chain_fallback(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    intercepted: List[int] = []
+
+    async def _handler1(route: Route) -> None:
+        intercepted.append(1)
+        await route.fallback()
+
+    await context.route("**/empty.html", _handler1)
+
+    async def _handler2(route: Route) -> None:
+        intercepted.append(2)
+        await route.fallback()
+
+    await context.route("**/empty.html", _handler2)
+
+    async def _handler3(route: Route) -> None:
+        intercepted.append(3)
+        await route.fallback()
+
+    await context.route("**/empty.html", _handler3)
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+async def test_should_chain_fallback_with_dynamic_url(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    intercepted: List[int] = []
+
+    async def _handler1(route: Route) -> None:
+        intercepted.append(1)
+        await route.fallback(url=server.EMPTY_PAGE)
+
+    await context.route("**/bar", _handler1)
+
+    async def _handler2(route: Route) -> None:
+        intercepted.append(2)
+        await route.fallback(url="http://localhost/bar")
+
+    await context.route("**/foo", _handler2)
+
+    async def _handler3(route: Route) -> None:
+        intercepted.append(3)
+        await route.fallback(url="http://localhost/foo")
+
+    await context.route("**/empty.html", _handler3)
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+async def test_should_not_chain_fulfill(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    failed = [False]
+
+    def handler(route: Route) -> None:
+        failed[0] = True
+
+    await context.route("**/empty.html", handler)
+    await context.route(
+        "**/empty.html",
+        lambda route: asyncio.create_task(route.fulfill(status=200, body="fulfilled")),
+    )
+    await context.route(
+        "**/empty.html", lambda route: asyncio.create_task(route.fallback())
+    )
+
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    body = await response.body()
+    assert body == b"fulfilled"
+    assert not failed[0]
+
+
+async def test_should_not_chain_abort(
+    page: Page,
+    context: BrowserContext,
+    server: Server,
+    is_webkit: bool,
+    is_firefox: bool,
+) -> None:
+    failed = [False]
+
+    def handler(route: Route) -> None:
+        failed[0] = True
+
+    await context.route("**/empty.html", handler)
+    await context.route(
+        "**/empty.html", lambda route: asyncio.create_task(route.abort())
+    )
+    await context.route(
+        "**/empty.html", lambda route: asyncio.create_task(route.fallback())
+    )
+
+    with pytest.raises(Error) as excinfo:
+        await page.goto(server.EMPTY_PAGE)
+    if is_webkit:
+        assert "Blocked by Web Inspector" in excinfo.value.message
+    elif is_firefox:
+        assert "NS_ERROR_FAILURE" in excinfo.value.message
+    else:
+        assert "net::ERR_FAILED" in excinfo.value.message
+    assert not failed[0]
+
+
+async def test_should_chain_fallback_into_page(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    intercepted = []
+
+    def _handler1(route: Route) -> None:
+        intercepted.append(1)
+        asyncio.create_task(route.fallback())
+
+    await context.route("**/empty.html", _handler1)
+
+    def _handler2(route: Route) -> None:
+        intercepted.append(2)
+        asyncio.create_task(route.fallback())
+
+    await context.route("**/empty.html", _handler2)
+
+    def _handler3(route: Route) -> None:
+        intercepted.append(3)
+        asyncio.create_task(route.fallback())
+
+    await context.route("**/empty.html", _handler3)
+
+    def _handler4(route: Route) -> None:
+        intercepted.append(4)
+        asyncio.create_task(route.fallback())
+
+    await page.route("**/empty.html", _handler4)
+
+    def _handler5(route: Route) -> None:
+        intercepted.append(5)
+        asyncio.create_task(route.fallback())
+
+    await page.route("**/empty.html", _handler5)
+
+    def _handler6(route: Route) -> None:
+        intercepted.append(6)
+        asyncio.create_task(route.fallback())
+
+    await page.route("**/empty.html", _handler6)
+
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [6, 5, 4, 3, 2, 1]
+
+
+async def test_should_fall_back_async(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    intercepted = []
+
+    async def _handler1(route: Route) -> None:
+        intercepted.append(1)
+        await asyncio.sleep(0.1)
+        await route.fallback()
+
+    await context.route("**/empty.html", _handler1)
+
+    async def _handler2(route: Route) -> None:
+        intercepted.append(2)
+        await asyncio.sleep(0.1)
+        await route.fallback()
+
+    await context.route("**/empty.html", _handler2)
+
+    async def _handler3(route: Route) -> None:
+        intercepted.append(3)
+        await asyncio.sleep(0.1)
+        await route.fallback()
+
+    await context.route("**/empty.html", _handler3)
+
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
diff --git a/tests/async/test_browsercontext_service_worker_policy.py b/tests/async/test_browsercontext_service_worker_policy.py
new file mode 100644
index 000000000..7adcd2d54
--- /dev/null
+++ b/tests/async/test_browsercontext_service_worker_policy.py
@@ -0,0 +1,37 @@
+# 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.
+from playwright.async_api import Browser
+from tests.server import Server
+
+
+async def test_should_allow_service_workers_by_default(
+    browser: Browser, server: Server
+) -> None:
+    context = await browser.new_context()
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/serviceworkers/fetchdummy/sw.html")
+    await page.evaluate("() => window.activationPromise")
+    await context.close()
+
+
+async def test_block_blocks_service_worker_registration(
+    browser: Browser, server: Server
+) -> None:
+    context = await browser.new_context(service_workers="block")
+    page = await context.new_page()
+    async with page.expect_console_message(
+        lambda m: "Service Worker registration blocked by Playwright" == m.text
+    ):
+        await page.goto(server.PREFIX + "/serviceworkers/fetchdummy/sw.html")
+    await context.close()
diff --git a/tests/async/test_browsercontext_storage_state.py b/tests/async/test_browsercontext_storage_state.py
index 8aac2b84f..02fb0e2b0 100644
--- a/tests/async/test_browsercontext_storage_state.py
+++ b/tests/async/test_browsercontext_storage_state.py
@@ -14,13 +14,16 @@
 
 import asyncio
 import json
+from pathlib import Path
+from typing import Optional
 
 import pytest
 
+from playwright.async_api import Browser, BrowserContext, Page, StorageState
+from tests.server import Server
 
-async def test_should_capture_local_storage(context, is_webkit, is_win):
-    if is_webkit and is_win:
-        pytest.skip()
+
+async def test_should_capture_local_storage(context: BrowserContext) -> None:
     page1 = await context.new_page()
     await page1.route(
         "**/*", lambda route: asyncio.create_task(route.fulfill(body="<html></html>"))
@@ -34,28 +37,40 @@ async def test_should_capture_local_storage(context, is_webkit, is_win):
     origins = state["origins"]
     assert len(origins) == 2
     assert origins[0] == {
-        "origin": "https://www.example.com",
-        "localStorage": [{"name": "name1", "value": "value1"}],
-    }
-    assert origins[1] == {
         "origin": "https://www.domain.com",
         "localStorage": [{"name": "name2", "value": "value2"}],
     }
+    assert origins[1] == {
+        "origin": "https://www.example.com",
+        "localStorage": [{"name": "name1", "value": "value1"}],
+    }
 
 
-async def test_should_set_local_storage(browser, is_webkit, is_win):
-    if is_webkit and is_win:
-        pytest.skip()
-    context = await browser.new_context(
-        storage_state={
-            "origins": [
+async def test_should_set_local_storage(browser: Browser) -> None:
+    storage_state: StorageState = {
+        "origins": [
+            {
+                "origin": "https://www.example.com",
+                "localStorage": [{"name": "name1", "value": "value1"}],
+            }
+        ]
+    }
+    # We intentionally hide the indexed_db part in our API for now
+    storage_state["origins"][0]["indexedDB"] = [  # type: ignore
+        {
+            "name": "db",
+            "version": 42,
+            "stores": [
                 {
-                    "origin": "https://www.example.com",
-                    "localStorage": [{"name": "name1", "value": "value1"}],
+                    "name": "store",
+                    "autoIncrement": False,
+                    "records": [{"key": "bar", "value": "foo"}],
+                    "indexes": [],
                 }
-            ]
+            ],
         }
-    )
+    ]
+    context = await browser.new_context(storage_state=storage_state)
 
     page = await context.new_page()
     await page.route(
@@ -64,10 +79,29 @@ async def test_should_set_local_storage(browser, is_webkit, is_win):
     await page.goto("https://www.example.com")
     local_storage = await page.evaluate("window.localStorage")
     assert local_storage == {"name1": "value1"}
+
+    indexed_db = await page.evaluate(
+        """async () => {
+        return new Promise((resolve, reject) => {
+            const openRequest = indexedDB.open('db', 42);
+            openRequest.addEventListener('success', () => {
+                const db = openRequest.result;
+                const transaction = db.transaction('store', 'readonly');
+                const getRequest = transaction.objectStore('store').get('bar');
+                getRequest.addEventListener('success', () => resolve(getRequest.result));
+                getRequest.addEventListener('error', () => reject(getRequest.error));
+            });
+            openRequest.addEventListener('error', () => reject(openRequest.error));
+        });
+    }"""
+    )
+    assert indexed_db == "foo"
     await context.close()
 
 
-async def test_should_round_trip_through_the_file(browser, context, tmpdir):
+async def test_should_round_trip_through_the_file(
+    browser: Browser, context: BrowserContext, tmp_path: Path
+) -> None:
     page1 = await context.new_page()
     await page1.route(
         "**/*",
@@ -82,7 +116,7 @@ async def test_should_round_trip_through_the_file(browser, context, tmpdir):
         }"""
     )
 
-    path = tmpdir / "storage-state.json"
+    path = tmp_path / "storage-state.json"
     state = await context.storage_state(path=path)
     with open(path, "r") as f:
         written = json.load(f)
@@ -100,3 +134,88 @@ async def test_should_round_trip_through_the_file(browser, context, tmpdir):
     cookie = await page2.evaluate("document.cookie")
     assert cookie == "username=John Doe"
     await context2.close()
+
+
+async def test_set_storage_state_should_apply_state_to_existing_context(
+    browser: Browser, browser_channel: Optional[str]
+) -> None:
+    if browser_channel and browser_channel.startswith("msedge"):
+        pytest.skip("Network.clearBrowserCache sometimes stalls on msedge")
+    src = await browser.new_context()
+    src_page = await src.new_page()
+    await src_page.route(
+        "**/*",
+        lambda route: asyncio.create_task(route.fulfill(body="<html></html>")),
+    )
+    await src_page.goto("https://www.example.com")
+    await src_page.evaluate('() => localStorage.setItem("k", "v")')
+    state = await src.storage_state()
+    await src.close()
+
+    dst = await browser.new_context()
+    dst_page = await dst.new_page()
+    await dst_page.route(
+        "**/*",
+        lambda route: asyncio.create_task(route.fulfill(body="<html></html>")),
+    )
+    await dst.set_storage_state(state)
+    await dst_page.goto("https://www.example.com")
+    assert await dst_page.evaluate('() => localStorage.getItem("k")') == "v"
+    await dst.close()
+
+
+async def test_should_serialiser_storage_state_with_lone_surrogates(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate(
+        """chars => window.localStorage.setItem('foo', String.fromCharCode(55934))"""
+    )
+    storage_state = await context.storage_state()
+    # 65533 is the Unicode replacement character
+    assert storage_state["origins"][0]["localStorage"][0]["value"] == chr(65533)
+
+
+async def test_should_serialise_indexed_db(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate(
+        """async () => {
+            await new Promise((resolve, reject) => {
+                const openRequest = indexedDB.open('db', 42);
+                openRequest.onupgradeneeded = () => {
+                openRequest.result.createObjectStore('store');
+                };
+                openRequest.onsuccess = () => {
+                const request = openRequest.result.transaction('store', 'readwrite')
+                    .objectStore('store')
+                    .put('foo', 'bar');
+                request.addEventListener('success', resolve);
+                request.addEventListener('error', reject);
+                };
+            });
+        }"""
+    )
+    assert await page.context.storage_state() == {"cookies": [], "origins": []}
+    assert await page.context.storage_state(indexed_db=True) == {
+        "cookies": [],
+        "origins": [
+            {
+                "origin": f"http://localhost:{server.PORT}",
+                "localStorage": [],
+                "indexedDB": [
+                    {
+                        "name": "db",
+                        "version": 42,
+                        "stores": [
+                            {
+                                "name": "store",
+                                "autoIncrement": False,
+                                "records": [{"key": "bar", "value": "foo"}],
+                                "indexes": [],
+                            }
+                        ],
+                    }
+                ],
+            }
+        ],
+    }
diff --git a/tests/async/test_browsertype_connect.py b/tests/async/test_browsertype_connect.py
new file mode 100644
index 000000000..ccb112ab9
--- /dev/null
+++ b/tests/async/test_browsertype_connect.py
@@ -0,0 +1,478 @@
+# 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 asyncio
+import os
+import re
+from pathlib import Path
+from typing import AsyncContextManager, Callable
+
+import pytest
+
+from playwright.async_api import BrowserType, Error, Playwright, Route, expect
+from tests.conftest import RemoteServer
+from tests.server import Server, TestServerRequest, WebSocketProtocol
+from tests.utils import chromium_version_less_than
+
+from .conftest import TraceViewerPage
+
+
+async def test_should_print_custom_ws_close_error(
+    server: Server, browser_type: BrowserType
+) -> None:
+    def _handle_ws(ws: WebSocketProtocol) -> None:
+        def _onMessage(payload: bytes, isBinary: bool) -> None:
+            ws.sendClose(code=4123, reason="Oh my!")
+
+        setattr(ws, "onMessage", _onMessage)
+
+    server.once_web_socket_connection(_handle_ws)
+    with pytest.raises(Error, match="Oh my!"):
+        await browser_type.connect(f"ws://localhost:{server.PORT}/ws")
+
+
+async def test_browser_type_connect_should_be_able_to_reconnect_to_a_browser(
+    server: Server, browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser = await browser_type.connect(remote_server.ws_endpoint)
+    browser_context = await browser.new_context()
+    assert len(browser_context.pages) == 0
+    page = await browser_context.new_page()
+    assert len(browser_context.pages) == 1
+    assert await page.evaluate("11 * 11") == 121
+    await page.goto(server.EMPTY_PAGE)
+    await browser.close()
+
+    browser = await browser_type.connect(remote_server.ws_endpoint)
+    browser_context = await browser.new_context()
+    page = await browser_context.new_page()
+    await page.goto(server.EMPTY_PAGE)
+    await browser.close()
+
+
+async def test_browser_type_connect_should_be_able_to_connect_two_browsers_at_the_same_time(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser1 = await browser_type.connect(remote_server.ws_endpoint)
+    assert len(browser1.contexts) == 0
+    await browser1.new_context()
+    assert len(browser1.contexts) == 1
+
+    browser2 = await browser_type.connect(remote_server.ws_endpoint)
+    assert len(browser2.contexts) == 0
+    await browser2.new_context()
+    assert len(browser2.contexts) == 1
+    assert len(browser1.contexts) == 1
+
+    await browser1.close()
+    page2 = await browser2.new_page()
+    # original browser should still work
+    assert await page2.evaluate("7 * 6") == 42
+
+    await browser2.close()
+
+
+async def test_browser_type_connect_disconnected_event_should_be_emitted_when_browser_is_closed_or_server_is_closed(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    # Launch another server to not affect other tests.
+    remote = launch_server()
+
+    browser1 = await browser_type.connect(remote.ws_endpoint)
+    browser2 = await browser_type.connect(remote.ws_endpoint)
+
+    disconnected1 = []
+    disconnected2 = []
+    browser1.on("disconnected", lambda _: disconnected1.append(True))
+    browser2.on("disconnected", lambda _: disconnected2.append(True))
+
+    page2 = await browser2.new_page()
+
+    await browser1.close()
+    assert len(disconnected1) == 1
+    assert len(disconnected2) == 0
+
+    remote.kill()
+    assert len(disconnected1) == 1
+
+    with pytest.raises(Error):
+        # Tickle connection so that it gets a chance to dispatch disconnect event.
+        await page2.title()
+    assert len(disconnected2) == 1
+
+
+async def test_browser_type_connect_disconnected_event_should_be_emitted_when_remote_killed_connection(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    # Launch another server to not affect other tests.
+    remote = launch_server()
+
+    browser = await browser_type.connect(remote.ws_endpoint)
+
+    disconnected = []
+    browser.on("disconnected", lambda _: disconnected.append(True))
+    page = await browser.new_page()
+    remote.kill()
+    with pytest.raises(Error):
+        await page.title()
+    assert len(disconnected) == 1
+
+
+async def test_browser_type_disconnected_event_should_have_browser_as_argument(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser = await browser_type.connect(remote_server.ws_endpoint)
+    event_payloads = []
+    browser.on("disconnected", lambda b: event_payloads.append(b))
+    await browser.close()
+    assert event_payloads[0] == browser
+
+
+async def test_browser_type_connect_set_browser_connected_state(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser = await browser_type.connect(remote_server.ws_endpoint)
+    assert browser.is_connected()
+    await browser.close()
+    assert browser.is_connected() is False
+
+
+async def test_browser_type_connect_should_throw_when_used_after_is_connected_returns_false(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser = await browser_type.connect(remote_server.ws_endpoint)
+    page = await browser.new_page()
+
+    remote_server.kill()
+
+    with pytest.raises(Error) as exc_info:
+        await page.evaluate("1 + 1")
+    assert "has been closed" in exc_info.value.message
+    assert browser.is_connected() is False
+
+
+async def test_browser_type_connect_should_reject_navigation_when_browser_closes(
+    server: Server, browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser = await browser_type.connect(remote_server.ws_endpoint)
+    page = await browser.new_page()
+    await browser.close()
+
+    with pytest.raises(Error) as exc_info:
+        await page.goto(server.PREFIX + "/one-style.html")
+    assert "has been closed" in exc_info.value.message
+
+
+async def test_should_not_allow_getting_the_path(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer], server: Server
+) -> None:
+    def handle_download(request: TestServerRequest) -> None:
+        request.setHeader("Content-Type", "application/octet-stream")
+        request.setHeader("Content-Disposition", "attachment")
+        request.write(b"Hello world")
+        request.finish()
+
+    server.set_route("/download", handle_download)
+
+    remote_server = launch_server()
+    browser = await browser_type.connect(remote_server.ws_endpoint)
+    page = await browser.new_page(accept_downloads=True)
+    await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
+    with pytest.raises(Error) as exc:
+        await download.path()
+    assert (
+        exc.value.message
+        == "Path is not available when using browser_type.connect(). Use save_as() to save a local copy."
+    )
+    remote_server.kill()
+
+
+async def test_prevent_getting_video_path(
+    browser_type: BrowserType,
+    launch_server: Callable[[], RemoteServer],
+    tmp_path: Path,
+    server: Server,
+) -> None:
+    remote_server = launch_server()
+    browser = await browser_type.connect(remote_server.ws_endpoint)
+    page = await browser.new_page(record_video_dir=tmp_path)
+    await page.goto(server.PREFIX + "/grid.html")
+    await browser.close()
+    assert page.video
+    with pytest.raises(Error) as exc:
+        await page.video.path()
+    assert (
+        exc.value.message
+        == "Path is not available when using browserType.connect(). Use save_as() to save a local copy."
+    )
+    remote_server.kill()
+
+
+async def test_connect_to_closed_server_without_hangs(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    remote_server.kill()
+    with pytest.raises(Error) as exc:
+        await browser_type.connect(remote_server.ws_endpoint)
+    assert "WebSocket error: " in exc.value.message
+
+
+async def test_should_fulfill_with_global_fetch_result(
+    browser_type: BrowserType,
+    launch_server: Callable[[], RemoteServer],
+    playwright: Playwright,
+    server: Server,
+) -> None:
+    # Launch another server to not affect other tests.
+    remote = launch_server()
+
+    browser = await browser_type.connect(remote.ws_endpoint)
+    context = await browser.new_context()
+    page = await context.new_page()
+
+    async def handle_request(route: Route) -> None:
+        request = await playwright.request.new_context()
+        response = await request.get(server.PREFIX + "/simple.json")
+        await route.fulfill(response=response)
+        await request.dispose()
+
+    await page.route("**/*", handle_request)
+
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 200
+    assert await response.json() == {"foo": "bar"}
+
+    remote.kill()
+
+
+async def test_should_upload_large_file(
+    browser_type: BrowserType,
+    launch_server: Callable[[], RemoteServer],
+    server: Server,
+    tmp_path: Path,
+) -> None:
+    remote = launch_server()
+
+    browser = await browser_type.connect(remote.ws_endpoint)
+    context = await browser.new_context()
+    page = await context.new_page()
+
+    await page.goto(server.PREFIX + "/input/fileupload.html")
+    large_file_path = tmp_path / "200MB.zip"
+    data = b"A" * 1024
+    with large_file_path.open("wb") as f:
+        for i in range(0, 200 * 1024 * 1024, len(data)):
+            f.write(data)
+    input = page.locator('input[type="file"]')
+    events = await input.evaluate_handle(
+        """
+        e => {
+            const events = [];
+            e.addEventListener('input', () => events.push('input'));
+            e.addEventListener('change', () => events.push('change'));
+            return events;
+        }
+    """
+    )
+
+    await input.set_input_files(large_file_path)
+    assert await input.evaluate("e => e.files[0].name") == "200MB.zip"
+    assert await events.evaluate("e => e") == ["input", "change"]
+
+    [request, _] = await asyncio.gather(
+        server.wait_for_request("/upload"),
+        page.click("input[type=submit]", timeout=60_000),
+    )
+
+    contents = request.args[b"file1"][0]
+    assert len(contents) == 200 * 1024 * 1024
+    assert contents[:1024] == data
+    # flake8: noqa: E203
+    assert contents[len(contents) - 1024 :] == data
+    assert request.post_body
+    match = re.search(
+        rb'^.*Content-Disposition: form-data; name="(?P<name>.*)"; filename="(?P<filename>.*)".*$',
+        request.post_body,
+        re.MULTILINE,
+    )
+    assert match
+    assert match.group("name") == b"file1"
+    assert match.group("filename") == b"200MB.zip"
+
+
+async def test_should_record_trace_with_source(
+    launch_server: Callable[[], RemoteServer],
+    server: Server,
+    tmp_path: Path,
+    browser_type: BrowserType,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
+) -> None:
+    remote = launch_server()
+    browser = await browser_type.connect(remote.ws_endpoint)
+    context = await browser.new_context()
+    page = await context.new_page()
+
+    await context.tracing.start(sources=True)
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<button>Click</button>")
+    await page.click("'Click'")
+    path = tmp_path / "trace1.zip"
+    await context.tracing.stop(path=path)
+
+    await context.close()
+    await browser.close()
+
+    async with show_trace_viewer(path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+            ]
+        )
+        await trace_viewer.show_source_tab()
+        await expect(trace_viewer.stack_frames).to_contain_text(
+            [
+                re.compile(r"test_should_record_trace_with_source"),
+            ]
+        )
+        await trace_viewer.select_action("Set content")
+        # Check that the source file is shown
+        await expect(
+            trace_viewer.page.locator(".source-tab-file-name")
+        ).to_have_attribute("title", re.compile(r".*test_browsertype_connect\.py"))
+        await expect(trace_viewer.page.locator(".source-line-running")).to_contain_text(
+            'page.set_content("<button>Click</button>")'
+        )
+
+
+async def test_should_record_trace_with_relative_trace_path(
+    launch_server: Callable[[], RemoteServer],
+    server: Server,
+    browser_type: BrowserType,
+) -> None:
+    remote = launch_server()
+    browser = await browser_type.connect(remote.ws_endpoint)
+    context = await browser.new_context()
+    page = await context.new_page()
+
+    await context.tracing.start(sources=True)
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<button>Click</button>")
+    await page.click("'Click'")
+    try:
+        await context.tracing.stop(path="trace1.zip")
+
+        await context.close()
+        await browser.close()
+
+        # make sure trace1.zip exists
+        assert Path("trace1.zip").exists()
+    finally:
+        Path("trace1.zip").unlink()
+
+
+async def test_set_input_files_should_preserve_last_modified_timestamp(
+    browser_type: BrowserType,
+    launch_server: Callable[[], RemoteServer],
+    assetdir: Path,
+) -> None:
+    # Launch another server to not affect other tests.
+    remote = launch_server()
+
+    browser = await browser_type.connect(remote.ws_endpoint)
+    context = await browser.new_context()
+    page = await context.new_page()
+
+    await page.set_content("<input type=file multiple=true/>")
+    input = page.locator("input")
+    files = ["file-to-upload.txt", "file-to-upload-2.txt"]
+    await input.set_input_files([assetdir / file for file in files])
+    assert await input.evaluate("input => [...input.files].map(f => f.name)") == files
+    timestamps = await input.evaluate(
+        "input => [...input.files].map(f => f.lastModified)"
+    )
+    expected_timestamps = [os.path.getmtime(assetdir / file) * 1000 for file in files]
+
+    # On Linux browser sometimes reduces the timestamp by 1ms: 1696272058110.0715  -> 1696272058109 or even
+    # rounds it to seconds in WebKit: 1696272058110 -> 1696272058000.
+    for i in range(len(timestamps)):
+        assert abs(timestamps[i] - expected_timestamps[i]) < 1000
+
+
+async def test_should_upload_a_folder(
+    browser_type: BrowserType,
+    launch_server: Callable[[], RemoteServer],
+    server: Server,
+    tmp_path: Path,
+    browser_name: str,
+    browser_version: str,
+    headless: bool,
+) -> None:
+    remote = launch_server()
+
+    browser = await browser_type.connect(remote.ws_endpoint)
+    context = await browser.new_context()
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/input/folderupload.html")
+    input = await page.query_selector("input")
+    assert input
+    dir = tmp_path / "file-upload-test"
+    dir.mkdir()
+    (dir / "file1.txt").write_text("file1 content")
+    (dir / "file2").write_text("file2 content")
+    (dir / "sub-dir").mkdir()
+    (dir / "sub-dir" / "really.txt").write_text("sub-dir file content")
+    await input.set_input_files(dir)
+    assert set(
+        await input.evaluate("e => [...e.files].map(f => f.webkitRelativePath)")
+    ) == set(
+        [
+            "file-upload-test/file1.txt",
+            "file-upload-test/file2",
+            # https://issues.chromium.org/issues/345393164
+            *(
+                []
+                if browser_name == "chromium"
+                and headless
+                and chromium_version_less_than(browser_version, "127.0.6533.0")
+                else ["file-upload-test/sub-dir/really.txt"]
+            ),
+        ]
+    )
+    webkit_relative_paths = await input.evaluate(
+        "e => [...e.files].map(f => f.webkitRelativePath)"
+    )
+    for i, webkit_relative_path in enumerate(webkit_relative_paths):
+        content = await input.evaluate(
+            """(e, i) => {
+            const reader = new FileReader();
+            const promise = new Promise(fulfill => reader.onload = fulfill);
+            reader.readAsText(e.files[i]);
+            return promise.then(() => reader.result);
+        }""",
+            i,
+        )
+        assert content == (dir / ".." / webkit_relative_path).read_text()
diff --git a/tests/async/test_browsertype_connect_cdp.py b/tests/async/test_browsertype_connect_cdp.py
new file mode 100644
index 000000000..dc66d3a07
--- /dev/null
+++ b/tests/async/test_browsertype_connect_cdp.py
@@ -0,0 +1,119 @@
+# 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 asyncio
+from typing import Dict
+
+import pytest
+import requests
+
+from playwright.async_api import BrowserType, Error
+from tests.server import Server, WebSocketProtocol, find_free_port
+
+pytestmark = pytest.mark.only_browser("chromium")
+
+
+async def test_connect_to_an_existing_cdp_session(
+    launch_arguments: Dict, browser_type: BrowserType
+) -> None:
+    port = find_free_port()
+    browser_server = await browser_type.launch(
+        **launch_arguments, args=[f"--remote-debugging-port={port}"]
+    )
+    cdp_browser = await browser_type.connect_over_cdp(f"http://127.0.0.1:{port}")
+    assert len(cdp_browser.contexts) == 1
+    await cdp_browser.close()
+    await browser_server.close()
+
+
+async def test_connect_to_an_existing_cdp_session_twice(
+    launch_arguments: Dict, browser_type: BrowserType, server: Server
+) -> None:
+    port = find_free_port()
+    browser_server = await browser_type.launch(
+        **launch_arguments, args=[f"--remote-debugging-port={port}"]
+    )
+    endpoint_url = f"http://127.0.0.1:{port}"
+    cdp_browser1 = await browser_type.connect_over_cdp(endpoint_url)
+    cdp_browser2 = await browser_type.connect_over_cdp(endpoint_url)
+    assert len(cdp_browser1.contexts) == 1
+    page1 = await cdp_browser1.contexts[0].new_page()
+    await page1.goto(server.EMPTY_PAGE)
+
+    assert len(cdp_browser2.contexts) == 1
+    page2 = await cdp_browser2.contexts[0].new_page()
+    await page2.goto(server.EMPTY_PAGE)
+
+    assert len(cdp_browser1.contexts[0].pages) == 2
+    assert len(cdp_browser2.contexts[0].pages) == 2
+
+    await cdp_browser1.close()
+    await cdp_browser2.close()
+    await browser_server.close()
+
+
+def _ws_endpoint_from_url(url: str) -> str:
+    response = requests.get(url)
+    assert response.ok
+    response_body = response.json()
+    return response_body["webSocketDebuggerUrl"]
+
+
+async def test_conect_over_a_ws_endpoint(
+    launch_arguments: Dict, browser_type: BrowserType, server: Server
+) -> None:
+    port = find_free_port()
+    browser_server = await browser_type.launch(
+        **launch_arguments, args=[f"--remote-debugging-port={port}"]
+    )
+    ws_endpoint = _ws_endpoint_from_url(f"http://127.0.0.1:{port}/json/version/")
+
+    cdp_browser1 = await browser_type.connect_over_cdp(ws_endpoint)
+    assert len(cdp_browser1.contexts) == 1
+    await cdp_browser1.close()
+
+    cdp_browser2 = await browser_type.connect_over_cdp(ws_endpoint)
+    assert len(cdp_browser2.contexts) == 1
+    await cdp_browser2.close()
+    await browser_server.close()
+
+
+async def test_connect_over_cdp_passing_header_works(
+    browser_type: BrowserType, server: Server
+) -> None:
+    server.send_on_web_socket_connection(b"incoming")
+    request = asyncio.create_task(server.wait_for_request("/ws"))
+    with pytest.raises(Error):
+        await browser_type.connect_over_cdp(
+            f"ws://127.0.0.1:{server.PORT}/ws",
+            headers={"foo": "bar"},
+            timeout=5000,
+        )
+    assert (await request).getHeader("foo") == "bar"
+
+
+async def test_should_print_custom_ws_close_error(
+    browser_type: BrowserType, server: Server
+) -> None:
+    def _handle_ws(ws: WebSocketProtocol) -> None:
+        def _onMessage(payload: bytes, isBinary: bool) -> None:
+            ws.sendClose(code=4123, reason="Oh my!")
+
+        setattr(ws, "onMessage", _onMessage)
+
+    server.once_web_socket_connection(_handle_ws)
+    with pytest.raises(Error, match="Browser logs:\n\nOh my!\n"):
+        await browser_type.connect_over_cdp(
+            f"ws://127.0.0.1:{server.PORT}/ws", headers={"foo": "bar"}
+        )
diff --git a/tests/async/test_cdp_session.py b/tests/async/test_cdp_session.py
index 6f0bfda68..5118ab9fa 100644
--- a/tests/async/test_cdp_session.py
+++ b/tests/async/test_cdp_session.py
@@ -12,27 +12,31 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import asyncio
-
 import pytest
 
-from playwright.async_api import Error
+from playwright.async_api import Browser, Error, Page
+from tests.server import Server
+from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
 
 
 @pytest.mark.only_browser("chromium")
-async def test_should_work(page):
+async def test_should_work(page: Page) -> None:
     client = await page.context.new_cdp_session(page)
-
-    await asyncio.gather(
-        client.send("Runtime.enable"),
-        client.send("Runtime.evaluate", {"expression": "window.foo = 'bar'"}),
+    events = []
+    client.on("Runtime.consoleAPICalled", lambda params: events.append(params))
+    await client.send("Runtime.enable")
+    result = await client.send(
+        "Runtime.evaluate",
+        {"expression": "window.foo = 'bar'; console.log('log'); 'result'"},
     )
+    assert result == {"result": {"type": "string", "value": "result"}}
     foo = await page.evaluate("() => window.foo")
     assert foo == "bar"
+    assert events[0]["args"][0]["value"] == "log"
 
 
 @pytest.mark.only_browser("chromium")
-async def test_should_send_events(page, server):
+async def test_should_receive_events(page: Page, server: Server) -> None:
     client = await page.context.new_cdp_session(page)
     await client.send("Network.enable")
     events = []
@@ -42,7 +46,7 @@ async def test_should_send_events(page, server):
 
 
 @pytest.mark.only_browser("chromium")
-async def test_should_be_able_to_detach_session(page):
+async def test_should_be_able_to_detach_session(page: Page) -> None:
     client = await page.context.new_cdp_session(page)
     await client.send("Runtime.enable")
     eval_response = await client.send(
@@ -54,11 +58,11 @@ async def test_should_be_able_to_detach_session(page):
         await client.send(
             "Runtime.evaluate", {"expression": "3 + 1", "returnByValue": True}
         )
-    assert "Target page, context or browser has been closed" in exc_info.value.message
+    assert TARGET_CLOSED_ERROR_MESSAGE in exc_info.value.message
 
 
 @pytest.mark.only_browser("chromium")
-async def test_should_not_break_page_close(browser):
+async def test_should_not_break_page_close(browser: Browser) -> None:
     context = await browser.new_context()
     page = await context.new_page()
     session = await page.context.new_cdp_session(page)
@@ -68,7 +72,7 @@ async def test_should_not_break_page_close(browser):
 
 
 @pytest.mark.only_browser("chromium")
-async def test_should_detach_when_page_closes(browser):
+async def test_should_detach_when_page_closes(browser: Browser) -> None:
     context = await browser.new_context()
     page = await context.new_page()
     session = await context.new_cdp_session(page)
@@ -76,3 +80,16 @@ async def test_should_detach_when_page_closes(browser):
     with pytest.raises(Error):
         await session.detach()
     await context.close()
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_work_with_main_frame(browser: Browser) -> None:
+    context = await browser.new_context()
+    page = await context.new_page()
+    client = await context.new_cdp_session(page.main_frame)
+    await client.send("Runtime.enable")
+    await client.send(
+        "Runtime.evaluate",
+        {"expression": "window.foo = 'bar'"},
+    )
+    assert await page.evaluate("() => window.foo") == "bar"
diff --git a/tests/async/test_check.py b/tests/async/test_check.py
index d4fcf43f0..428ca2a7b 100644
--- a/tests/async/test_check.py
+++ b/tests/async/test_check.py
@@ -12,32 +12,34 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from playwright.async_api import Page
 
-async def test_check_the_box(page):
+
+async def test_check_the_box(page: Page) -> None:
     await page.set_content('<input id="checkbox" type="checkbox"></input>')
     await page.check("input")
     assert await page.evaluate("checkbox.checked")
 
 
-async def test_not_check_the_checked_box(page):
+async def test_not_check_the_checked_box(page: Page) -> None:
     await page.set_content('<input id="checkbox" type="checkbox" checked></input>')
     await page.check("input")
     assert await page.evaluate("checkbox.checked")
 
 
-async def test_uncheck_the_box(page):
+async def test_uncheck_the_box(page: Page) -> None:
     await page.set_content('<input id="checkbox" type="checkbox" checked></input>')
     await page.uncheck("input")
     assert await page.evaluate("checkbox.checked") is False
 
 
-async def test_not_uncheck_the_unchecked_box(page):
+async def test_not_uncheck_the_unchecked_box(page: Page) -> None:
     await page.set_content('<input id="checkbox" type="checkbox"></input>')
     await page.uncheck("input")
     assert await page.evaluate("checkbox.checked") is False
 
 
-async def test_check_the_box_by_label(page):
+async def test_check_the_box_by_label(page: Page) -> None:
     await page.set_content(
         '<label for="checkbox"><input id="checkbox" type="checkbox"></input></label>'
     )
@@ -45,7 +47,7 @@ async def test_check_the_box_by_label(page):
     assert await page.evaluate("checkbox.checked")
 
 
-async def test_check_the_box_outside_label(page):
+async def test_check_the_box_outside_label(page: Page) -> None:
     await page.set_content(
         '<label for="checkbox">Text</label><div><input id="checkbox" type="checkbox"></input></div>'
     )
@@ -53,7 +55,7 @@ async def test_check_the_box_outside_label(page):
     assert await page.evaluate("checkbox.checked")
 
 
-async def test_check_the_box_inside_label_without_id(page):
+async def test_check_the_box_inside_label_without_id(page: Page) -> None:
     await page.set_content(
         '<label>Text<span><input id="checkbox" type="checkbox"></input></span></label>'
     )
@@ -61,7 +63,7 @@ async def test_check_the_box_inside_label_without_id(page):
     assert await page.evaluate("checkbox.checked")
 
 
-async def test_check_radio(page):
+async def test_check_radio(page: Page) -> None:
     await page.set_content(
         """
       <input type='radio'>one</input>
@@ -72,7 +74,7 @@ async def test_check_radio(page):
     assert await page.evaluate("two.checked")
 
 
-async def test_check_the_box_by_aria_role(page):
+async def test_check_the_box_by_aria_role(page: Page) -> None:
     await page.set_content(
         """<div role='checkbox' id='checkbox'>CHECKBOX</div>
       <script>
diff --git a/tests/async/test_chromium_tracing.py b/tests/async/test_chromium_tracing.py
new file mode 100644
index 000000000..4cd796e0d
--- /dev/null
+++ b/tests/async/test_chromium_tracing.py
@@ -0,0 +1,119 @@
+# 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 json
+import os
+from pathlib import Path
+
+import pytest
+
+from playwright.async_api import Browser, Page
+from tests.server import Server
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_output_a_trace(
+    browser: Browser, page: Page, server: Server, tmp_path: Path
+) -> None:
+    output_file = tmp_path / "trace.json"
+    await browser.start_tracing(page=page, screenshots=True, path=output_file)
+    await page.goto(server.PREFIX + "/grid.html")
+    await browser.stop_tracing()
+    assert os.path.getsize(output_file) > 0
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_create_directories_as_needed(
+    browser: Browser, page: Page, server: Server, tmp_path: Path
+) -> None:
+    output_file = tmp_path / "these" / "are" / "directories" / "trace.json"
+    await browser.start_tracing(page=page, screenshots=True, path=output_file)
+    await page.goto(server.PREFIX + "/grid.html")
+    await browser.stop_tracing()
+    assert os.path.getsize(output_file) > 0
+
+
+async def rafraf(target: Page, count: int = 1) -> None:
+    for _ in range(count):
+        await target.evaluate(
+            "async () => await new Promise(f => window.requestAnimationFrame(() => window.requestAnimationFrame(f)));"
+        )
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_run_with_custom_categories_if_provided(
+    browser: Browser, page: Page, tmp_path: Path
+) -> None:
+    output_file = tmp_path / "trace.json"
+    await browser.start_tracing(
+        page=page,
+        path=output_file,
+        categories=["disabled-by-default-cc.debug"],
+    )
+    await rafraf(page)
+    await browser.stop_tracing()
+    with open(output_file, mode="r") as of:
+        trace_json = json.load(of)
+        trace_config = trace_json["metadata"].get("trace-config")
+        trace_events = trace_json["traceEvents"]
+        assert (
+            trace_config is not None and "disabled-by-default-cc.debug" in trace_config
+        ) or any(
+            event.get("cat") == "disabled-by-default-cc.debug" for event in trace_events
+        )
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_throw_if_tracing_on_two_pages(
+    browser: Browser, page: Page, tmp_path: Path
+) -> None:
+    output_file_1 = tmp_path / "trace1.json"
+    await browser.start_tracing(page=page, screenshots=True, path=output_file_1)
+    output_file_2 = tmp_path / "trace2.json"
+    with pytest.raises(Exception):
+        await browser.start_tracing(page=page, screenshots=True, path=output_file_2)
+    await browser.stop_tracing()
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_return_a_buffer(
+    browser: Browser, page: Page, server: Server, tmp_path: Path
+) -> None:
+    output_file = tmp_path / "trace.json"
+    await browser.start_tracing(page=page, path=output_file, screenshots=True)
+    await page.goto(server.PREFIX + "/grid.html")
+    value = await browser.stop_tracing()
+    with open(output_file, mode="r") as trace_file:
+        assert trace_file.read() == value.decode()
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_work_without_options(
+    browser: Browser, page: Page, server: Server
+) -> None:
+    await browser.start_tracing()
+    await page.goto(server.PREFIX + "/grid.html")
+    trace = await browser.stop_tracing()
+    assert trace
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_support_a_buffer_without_a_path(
+    browser: Browser, page: Page, server: Server
+) -> None:
+    await browser.start_tracing(page=page, screenshots=True)
+    await page.goto(server.PREFIX + "/grid.html")
+    await rafraf(page)
+    trace = await browser.stop_tracing()
+    assert "screenshot" in trace.decode()
diff --git a/tests/async/test_click.py b/tests/async/test_click.py
index 4be435623..f267635bf 100644
--- a/tests/async/test_click.py
+++ b/tests/async/test_click.py
@@ -13,26 +13,31 @@
 # limitations under the License.
 
 import asyncio
+from datetime import timedelta
+from typing import Optional
 
 import pytest
 
-from playwright.async_api import Error, TimeoutError
+from playwright.async_api import Browser, Error, Page, Playwright, TimeoutError
+from tests.server import Server
 
+from .utils import Utils
 
-async def give_it_a_chance_to_click(page):
+
+async def give_it_a_chance_to_click(page: Page) -> None:
     for _ in range(5):
         await page.evaluate(
             "() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f)))"
         )
 
 
-async def test_click_the_button(page, server):
+async def test_click_the_button(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.click("button")
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_click_svg(page, server):
+async def test_click_svg(page: Page, server: Server) -> None:
     await page.set_content(
         """
         <svg height="100" width="100">
@@ -44,14 +49,18 @@ async def test_click_svg(page, server):
     assert await page.evaluate("window.__CLICKED") == 42
 
 
-async def test_click_the_button_if_window_node_is_removed(page, server):
+async def test_click_the_button_if_window_node_is_removed(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.evaluate("() => delete window.Node")
     await page.click("button")
     assert await page.evaluate("() => result") == "Clicked"
 
 
-async def test_click_on_a_span_with_an_inline_element_inside(page, server):
+async def test_click_on_a_span_with_an_inline_element_inside(
+    page: Page, server: Server
+) -> None:
     await page.set_content(
         """
         <style>
@@ -66,7 +75,7 @@ async def test_click_on_a_span_with_an_inline_element_inside(page, server):
     assert await page.evaluate("window.CLICKED") == 42
 
 
-async def test_click_not_throw_when_page_closes(browser, server):
+async def test_click_not_throw_when_page_closes(browser: Browser) -> None:
     context = await browser.new_context()
     page = await context.new_page()
     try:
@@ -79,7 +88,7 @@ async def test_click_not_throw_when_page_closes(browser, server):
     await context.close()
 
 
-async def test_click_the_button_after_navigation(page, server):
+async def test_click_the_button_after_navigation(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.click("button")
     await page.goto(server.PREFIX + "/input/button.html")
@@ -87,7 +96,9 @@ async def test_click_the_button_after_navigation(page, server):
     assert await page.evaluate("() => result") == "Clicked"
 
 
-async def test_click_the_button_after_a_cross_origin_navigation_(page, server):
+async def test_click_the_button_after_a_cross_origin_navigation_(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.click("button")
     await page.goto(server.CROSS_PROCESS_PREFIX + "/input/button.html")
@@ -95,18 +106,19 @@ async def test_click_the_button_after_a_cross_origin_navigation_(page, server):
     assert await page.evaluate("() => result") == "Clicked"
 
 
-async def test_click_with_disabled_javascript(browser, server):
+async def test_click_with_disabled_javascript(browser: Browser, server: Server) -> None:
     context = await browser.new_context(java_script_enabled=False)
     page = await context.new_page()
     await page.goto(server.PREFIX + "/wrappedlink.html")
-    await asyncio.gather(page.click("a"), page.wait_for_navigation())
+    async with page.expect_navigation():
+        await page.click("a")
     assert page.url == server.PREFIX + "/wrappedlink.html#clicked"
     await context.close()
 
 
 async def test_click_when_one_of_inline_box_children_is_outside_of_viewport(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.set_content(
         """
         <style>
@@ -122,7 +134,7 @@ async def test_click_when_one_of_inline_box_children_is_outside_of_viewport(
     assert await page.evaluate("() => window.CLICKED") == 42
 
 
-async def test_select_the_text_by_triple_clicking(page, server):
+async def test_select_the_text_by_triple_clicking(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     text = "This is the text that we are going to try to select. Let's see how it goes."
     await page.fill("textarea", text)
@@ -138,7 +150,7 @@ async def test_select_the_text_by_triple_clicking(page, server):
     )
 
 
-async def test_click_offscreen_buttons(page, server):
+async def test_click_offscreen_buttons(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/offscreenbuttons.html")
     messages = []
     page.on("console", lambda msg: messages.append(msg.text))
@@ -161,30 +173,31 @@ async def test_click_offscreen_buttons(page, server):
     ]
 
 
-async def test_waitFor_visible_when_already_visible(page, server):
+async def test_waitFor_visible_when_already_visible(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.click("button")
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_wait_with_force(page, server):
-    error = None
+async def test_wait_with_force(page: Page, server: Server) -> None:
+    error: Optional[Error] = None
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "b => b.style.display = 'none'")
     try:
         await page.click("button", force=True)
     except Error as e:
         error = e
+    assert error
     assert "Element is not visible" in error.message
     assert await page.evaluate("result") == "Was not clicked"
 
 
-async def test_wait_for_display_none_to_be_gone(page, server):
-    done = list()
+async def test_wait_for_display_none_to_be_gone(page: Page, server: Server) -> None:
+    done = []
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "b => b.style.display = 'none'")
 
-    async def click():
+    async def click() -> None:
         await page.click("button", timeout=0)
         done.append(True)
 
@@ -198,12 +211,14 @@ async def click():
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_wait_for_visibility_hidden_to_be_gone(page, server):
-    done = list()
+async def test_wait_for_visibility_hidden_to_be_gone(
+    page: Page, server: Server
+) -> None:
+    done = []
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "b => b.style.visibility = 'hidden'")
 
-    async def click():
+    async def click() -> None:
         await page.click("button", timeout=0)
         done.append(True)
 
@@ -217,7 +232,9 @@ async def click():
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_timeout_waiting_for_display_none_to_be_gone(page, server):
+async def test_timeout_waiting_for_display_none_to_be_gone(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "b => b.style.display = 'none'")
     try:
@@ -225,11 +242,14 @@ async def test_timeout_waiting_for_display_none_to_be_gone(page, server):
     except Error as e:
         error = e
     assert "Timeout 5000ms exceeded" in error.message
-    assert "waiting for element to be visible, enabled and not moving" in error.message
-    assert "element is not visible - waiting" in error.message
+    assert "waiting for element to be visible, enabled and stable" in error.message
+    assert "element is not visible" in error.message
+    assert "retrying click action" in error.message
 
 
-async def test_timeout_waiting_for_visbility_hidden_to_be_gone(page, server):
+async def test_timeout_waiting_for_visbility_hidden_to_be_gone(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "b => b.style.visibility = 'hidden'")
     try:
@@ -237,16 +257,19 @@ async def test_timeout_waiting_for_visbility_hidden_to_be_gone(page, server):
     except Error as e:
         error = e
     assert "Timeout 5000ms exceeded" in error.message
-    assert "waiting for element to be visible, enabled and not moving" in error.message
-    assert "element is not visible - waiting" in error.message
+    assert "waiting for element to be visible, enabled and stable" in error.message
+    assert "element is not visible" in error.message
+    assert "retrying click action" in error.message
 
 
-async def test_waitFor_visible_when_parent_is_hidden(page, server):
-    done = list()
+async def test_waitFor_visible_when_parent_is_hidden(
+    page: Page, server: Server
+) -> None:
+    done = []
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "b => b.parentElement.style.display = 'none'")
 
-    async def click():
+    async def click() -> None:
         await page.click("button", timeout=0)
         done.append(True)
 
@@ -261,13 +284,13 @@ async def click():
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_click_wrapped_links(page, server):
+async def test_click_wrapped_links(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/wrappedlink.html")
     await page.click("a")
     assert await page.evaluate("window.__clicked")
 
 
-async def test_click_on_checkbox_input_and_toggle(page, server):
+async def test_click_on_checkbox_input_and_toggle(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/checkbox.html")
     assert await page.evaluate("() => result.check") is None
     await page.click("input#agree")
@@ -286,7 +309,7 @@ async def test_click_on_checkbox_input_and_toggle(page, server):
     assert await page.evaluate("result.check") is False
 
 
-async def test_click_on_checkbox_label_and_toggle(page, server):
+async def test_click_on_checkbox_label_and_toggle(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/checkbox.html")
     assert await page.evaluate("result.check") is None
     await page.click('label[for="agree"]')
@@ -300,7 +323,9 @@ async def test_click_on_checkbox_label_and_toggle(page, server):
     assert await page.evaluate("result.check") is False
 
 
-async def test_not_hang_with_touch_enabled_viewports(playwright, server, browser):
+async def test_not_hang_with_touch_enabled_viewports(
+    playwright: Playwright, browser: Browser
+) -> None:
     iphone_6 = playwright.devices["iPhone 6"]
     context = await browser.new_context(
         viewport=iphone_6["viewport"], has_touch=iphone_6["has_touch"]
@@ -312,7 +337,7 @@ async def test_not_hang_with_touch_enabled_viewports(playwright, server, browser
     await context.close()
 
 
-async def test_scroll_and_click_the_button(page, server):
+async def test_scroll_and_click_the_button(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/scrollable.html")
     await page.click("#button-5")
     assert (
@@ -326,7 +351,7 @@ async def test_scroll_and_click_the_button(page, server):
     )
 
 
-async def test_double_click_the_button(page, server):
+async def test_double_click_the_button(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.evaluate(
         """() => {
@@ -341,7 +366,7 @@ async def test_double_click_the_button(page, server):
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_click_a_partially_obscured_button(page, server):
+async def test_click_a_partially_obscured_button(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.evaluate(
         """() => {
@@ -356,13 +381,15 @@ async def test_click_a_partially_obscured_button(page, server):
     assert await page.evaluate("() => window.result") == "Clicked"
 
 
-async def test_click_a_rotated_button(page, server):
+async def test_click_a_rotated_button(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/rotatedButton.html")
     await page.click("button")
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_fire_contextmenu_event_on_right_click(page, server):
+async def test_fire_contextmenu_event_on_right_click(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/scrollable.html")
     await page.click("#button-8", button="right")
     assert (
@@ -371,23 +398,28 @@ async def test_fire_contextmenu_event_on_right_click(page, server):
     )
 
 
-async def test_click_links_which_cause_navigation(page, server):
+async def test_click_links_which_cause_navigation(page: Page, server: Server) -> None:
     await page.set_content(f'<a href="{server.EMPTY_PAGE}">empty.html</a>')
     # This await should not hang.
     await page.click("a")
 
 
-async def test_click_the_button_inside_an_iframe(page, server, utils):
+async def test_click_the_button_inside_an_iframe(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.set_content('<div style="width:100px;height:100px">spacer</div>')
     await utils.attach_frame(page, "button-test", server.PREFIX + "/input/button.html")
     frame = page.frames[1]
     button = await frame.query_selector("button")
+    assert button
     await button.click()
     assert await frame.evaluate("window.result") == "Clicked"
 
 
-async def test_click_the_button_with_device_scale_factor_set(browser, server, utils):
+async def test_click_the_button_with_device_scale_factor_set(
+    browser: Browser, server: Server, utils: Utils
+) -> None:
     context = await browser.new_context(
         viewport={"width": 400, "height": 400}, device_scale_factor=5
     )
@@ -397,33 +429,38 @@ async def test_click_the_button_with_device_scale_factor_set(browser, server, ut
     await utils.attach_frame(page, "button-test", server.PREFIX + "/input/button.html")
     frame = page.frames[1]
     button = await frame.query_selector("button")
+    assert button
     await button.click()
     assert await frame.evaluate("window.result") == "Clicked"
     await context.close()
 
 
-async def test_click_the_button_with_px_border_with_offset(page, server, is_webkit):
+async def test_click_the_button_with_px_border_with_offset(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "button => button.style.borderWidth = '8px'")
     await page.click("button", position={"x": 20, "y": 10})
     assert await page.evaluate("result") == "Clicked"
-    # Safari reports border-relative offsetX/offsetY.
-    assert await page.evaluate("offsetX") == 20 + 8 if is_webkit else 20
-    assert await page.evaluate("offsetY") == 10 + 8 if is_webkit else 10
+    assert await page.evaluate("offsetX") == 20
+    assert await page.evaluate("offsetY") == 10
 
 
-async def test_click_the_button_with_em_border_with_offset(page, server, is_webkit):
+async def test_click_the_button_with_em_border_with_offset(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "button => button.style.borderWidth = '2em'")
     await page.eval_on_selector("button", "button => button.style.fontSize = '12px'")
     await page.click("button", position={"x": 20, "y": 10})
     assert await page.evaluate("result") == "Clicked"
-    # Safari reports border-relative offsetX/offsetY.
-    assert await page.evaluate("offsetX") == 12 * 2 + 20 if is_webkit else 20
-    assert await page.evaluate("offsetY") == 12 * 2 + 10 if is_webkit else 10
+    assert await page.evaluate("offsetX") == 20
+    assert await page.evaluate("offsetY") == 10
 
 
-async def test_click_a_very_large_button_with_offset(page, server, is_webkit):
+async def test_click_a_very_large_button_with_offset(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector("button", "button => button.style.borderWidth = '8px'")
     await page.eval_on_selector(
@@ -431,14 +468,13 @@ async def test_click_a_very_large_button_with_offset(page, server, is_webkit):
     )
     await page.click("button", position={"x": 1900, "y": 1910})
     assert await page.evaluate("() => window.result") == "Clicked"
-    # Safari reports border-relative offsetX/offsetY.
-    assert await page.evaluate("() => offsetX") == 1900 + 8 if is_webkit else 1900
-    assert await page.evaluate("() => offsetY") == 1910 + 8 if is_webkit else 1910
+    assert await page.evaluate("() => offsetX") == 1900
+    assert await page.evaluate("() => offsetY") == 1910
 
 
 async def test_click_a_button_in_scrolling_container_with_offset(
-    page, server, is_webkit
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector(
         "button",
@@ -457,15 +493,14 @@ async def test_click_a_button_in_scrolling_container_with_offset(
 
     await page.click("button", position={"x": 1900, "y": 1910})
     assert await page.evaluate("window.result") == "Clicked"
-    # Safari reports border-relative offsetX/offsetY.
-    assert await page.evaluate("offsetX") == 1900 + 8 if is_webkit else 1900
-    assert await page.evaluate("offsetY") == 1910 + 8 if is_webkit else 1910
+    assert await page.evaluate("offsetX") == 1900
+    assert await page.evaluate("offsetY") == 1910
 
 
 @pytest.mark.skip_browser("firefox")
 async def test_click_the_button_with_offset_with_page_scale(
-    browser, server, is_chromium, is_webkit
-):
+    browser: Browser, server: Server
+) -> None:
     context = await browser.new_context(
         viewport={"width": 400, "height": 400}, is_mobile=True
     )
@@ -481,19 +516,19 @@ async def test_click_the_button_with_offset_with_page_scale(
 
     await page.click("button", position={"x": 20, "y": 10})
     assert await page.evaluate("result") == "Clicked"
-    expected = {"x": 28, "y": 18}
-    if is_webkit:
-        # WebKit rounds up during css -> dip -> css conversion.
-        expected = {"x": 29, "y": 19}
-    elif is_chromium:
-        # Chromium rounds down during css -> dip -> css conversion.
-        expected = {"x": 27, "y": 18}
-    assert await page.evaluate("pageX") == expected["x"]
-    assert await page.evaluate("pageY") == expected["y"]
+
+    def _assert_close_to(expected: int, actual: int) -> None:
+        if abs(expected - actual) > 2:
+            raise AssertionError(f"Expected: {expected}, received: {actual}")
+
+    # Expect 20;10 + 8px of border in each direction. Allow some delta as different
+    # browsers round up or down differently during css -> dip -> css conversion.
+    _assert_close_to(28, await page.evaluate("pageX"))
+    _assert_close_to(18, await page.evaluate("pageY"))
     await context.close()
 
 
-async def test_wait_for_stable_position(page, server):
+async def test_wait_for_stable_position(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector(
         "button",
@@ -509,6 +544,10 @@ async def test_wait_for_stable_position(page, server):
             document.body.style.margin = '0';
         }""",
     )
+    # rafraf for Firefox to kick in the animation.
+    await page.evaluate(
+        "() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f)))"
+    )
 
     await page.click("button")
     assert await page.evaluate("window.result") == "Clicked"
@@ -516,27 +555,31 @@ async def test_wait_for_stable_position(page, server):
     assert await page.evaluate("pageY") == 10
 
 
-async def test_timeout_waiting_for_stable_position(page, server):
+async def test_timeout_waiting_for_stable_position(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     button = await page.query_selector("button")
+    assert button
     await button.evaluate(
         """button => {
             button.style.transition = 'margin 5s linear 0s'
             button.style.marginLeft = '200px'
         }"""
     )
+    # rafraf for Firefox to kick in the animation.
+    await page.evaluate(
+        "() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f)))"
+    )
 
-    error = None
-    try:
-        await button.click(timeout=5000)
-    except Error as e:
-        error = e
-    assert "Timeout 5000ms exceeded." in error.message
-    assert "waiting for element to be visible, enabled and not moving" in error.message
-    assert "element is moving - waiting" in error.message
+    with pytest.raises(Error) as exc_info:
+        await button.click(timeout=3000)
+    error = exc_info.value
+    assert "Timeout 3000ms exceeded." in error.message
+    assert "waiting for element to be visible, enabled and stable" in error.message
+    assert "element is not stable" in error.message
+    assert "retrying click action" in error.message
 
 
-async def test_wait_for_becoming_hit_target(page, server):
+async def test_wait_for_becoming_hit_target(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.eval_on_selector(
         "button",
@@ -560,7 +603,7 @@ async def test_wait_for_becoming_hit_target(page, server):
 
     clicked = [False]
 
-    async def click():
+    async def click() -> None:
         await page.click("button")
         clicked.append(True)
 
@@ -577,9 +620,10 @@ async def click():
     assert await page.evaluate("() => window.result") == "Clicked"
 
 
-async def test_timeout_waiting_for_hit_target(page, server):
+async def test_timeout_waiting_for_hit_target(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     button = await page.query_selector("button")
+    assert button
     await page.evaluate(
         """() => {
       document.body.style.position = 'relative'
@@ -598,14 +642,18 @@ async def test_timeout_waiting_for_hit_target(page, server):
         await button.click(timeout=5000)
     except TimeoutError as e:
         error = e
+    assert error
     assert "Timeout 5000ms exceeded." in error.message
     assert '<div id="blocker"></div> intercepts pointer events' in error.message
     assert "retrying click action" in error.message
 
 
-async def test_fail_when_obscured_and_not_waiting_for_hit_target(page, server):
+async def test_fail_when_obscured_and_not_waiting_for_hit_target(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     button = await page.query_selector("button")
+    assert button
     await page.evaluate(
         """() => {
             document.body.style.position = 'relative'
@@ -623,13 +671,13 @@ async def test_fail_when_obscured_and_not_waiting_for_hit_target(page, server):
     assert await page.evaluate("window.result") == "Was not clicked"
 
 
-async def test_wait_for_button_to_be_enabled(page, server):
+async def test_wait_for_button_to_be_enabled(page: Page, server: Server) -> None:
     await page.set_content(
         '<button onclick="javascript:window.__CLICKED=true;" disabled><span>Click target</span></button>'
     )
-    done = list()
+    done = []
 
-    async def click():
+    async def click() -> None:
         await page.click("text=Click target")
         done.append(True)
 
@@ -642,27 +690,31 @@ async def click():
     assert await page.evaluate("window.__CLICKED")
 
 
-async def test_timeout_waiting_for_button_to_be_enabled(page, server):
+async def test_timeout_waiting_for_button_to_be_enabled(
+    page: Page, server: Server
+) -> None:
     await page.set_content(
         '<button onclick="javascript:window.__CLICKED=true;" disabled><span>Click target</span></button>'
     )
-    error = None
+    error: Optional[Error] = None
     try:
         await page.click("text=Click target", timeout=3000)
     except TimeoutError as e:
         error = e
     assert await page.evaluate("window.__CLICKED") is None
+    assert error
     assert "Timeout 3000ms exceeded" in error.message
-    assert "element is disabled - waiting" in error.message
+    assert "element is not enabled" in error.message
+    assert "retrying click action" in error.message
 
 
-async def test_wait_for_input_to_be_enabled(page, server):
+async def test_wait_for_input_to_be_enabled(page: Page, server: Server) -> None:
     await page.set_content(
         '<input onclick="javascript:window.__CLICKED=true;" disabled>'
     )
     done = []
 
-    async def click():
+    async def click() -> None:
         await page.click("input")
         done.append(True)
 
@@ -675,13 +727,21 @@ async def click():
     assert await page.evaluate("window.__CLICKED")
 
 
-async def test_wait_for_select_to_be_enabled(page, server):
+async def test_wait_for_select_to_be_enabled(page: Page, server: Server) -> None:
     await page.set_content(
-        '<select onclick="javascript:window.__CLICKED=true;" disabled><option selected>Hello</option></select>'
+        """
+        <select disabled><option selected>Hello</option></select>
+        <script>
+        document.querySelector('select').addEventListener('mousedown', event => {
+            window.__CLICKED=true;
+            event.preventDefault();
+        });
+        </script>
+    """
     )
     done = []
 
-    async def click():
+    async def click() -> None:
         await page.click("select")
         done.append(True)
 
@@ -694,7 +754,7 @@ async def click():
     assert await page.evaluate("window.__CLICKED")
 
 
-async def test_click_disabled_div(page, server):
+async def test_click_disabled_div(page: Page, server: Server) -> None:
     await page.set_content(
         '<div onclick="javascript:window.__CLICKED=true;" disabled>Click target</div>'
     )
@@ -702,7 +762,9 @@ async def test_click_disabled_div(page, server):
     assert await page.evaluate("window.__CLICKED")
 
 
-async def test_climb_dom_for_inner_label_with_pointer_events_none(page, server):
+async def test_climb_dom_for_inner_label_with_pointer_events_none(
+    page: Page, server: Server
+) -> None:
     await page.set_content(
         '<button onclick="javascript:window.__CLICKED=true;"><label style="pointer-events:none">Click target</label></button>'
     )
@@ -710,7 +772,7 @@ async def test_climb_dom_for_inner_label_with_pointer_events_none(page, server):
     assert await page.evaluate("window.__CLICKED")
 
 
-async def test_climb_up_to_role_button(page, server):
+async def test_climb_up_to_role_button(page: Page, server: Server) -> None:
     await page.set_content(
         '<div role=button onclick="javascript:window.__CLICKED=true;"><div style="pointer-events:none"><span><div>Click target</div></span></div>'
     )
@@ -719,14 +781,14 @@ async def test_climb_up_to_role_button(page, server):
 
 
 async def test_wait_for_BUTTON_to_be_clickable_when_it_has_pointer_events_none(
-    page, server
-):
+    page: Page,
+) -> None:
     await page.set_content(
         '<button onclick="javascript:window.__CLICKED=true;" style="pointer-events:none"><span>Click target</span></button>'
     )
     done = []
 
-    async def click():
+    async def click() -> None:
         await page.click("text=Click target")
         done.append(True)
 
@@ -742,8 +804,8 @@ async def click():
 
 
 async def test_wait_for_LABEL_to_be_clickable_when_it_has_pointer_events_none(
-    page, server
-):
+    page: Page,
+) -> None:
     await page.set_content(
         '<label onclick="javascript:window.__CLICKED=true;" style="pointer-events:none"><span>Click target</span></label>'
     )
@@ -759,7 +821,7 @@ async def test_wait_for_LABEL_to_be_clickable_when_it_has_pointer_events_none(
     assert await page.evaluate("window.__CLICKED")
 
 
-async def test_update_modifiers_correctly(page, server):
+async def test_update_modifiers_correctly(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.click("button", modifiers=["Shift"])
     assert await page.evaluate("shiftKey")
@@ -776,7 +838,9 @@ async def test_update_modifiers_correctly(page, server):
     assert await page.evaluate("shiftKey") is False
 
 
-async def test_click_an_offscreen_element_when_scroll_behavior_is_smooth(page):
+async def test_click_an_offscreen_element_when_scroll_behavior_is_smooth(
+    page: Page,
+) -> None:
     await page.set_content(
         """
         <div style="border: 1px solid black; height: 500px; overflow: auto; width: 500px; scroll-behavior: smooth">
@@ -789,25 +853,30 @@ async def test_click_an_offscreen_element_when_scroll_behavior_is_smooth(page):
 
 
 async def test_report_nice_error_when_element_is_detached_and_force_clicked(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/animating-button.html")
     await page.evaluate("addButton()")
     handle = await page.query_selector("button")
+    assert handle
     await page.evaluate("stopButton(true)")
-    error = None
+    error: Optional[Error] = None
     try:
         await handle.click(force=True)
     except Error as e:
         error = e
     assert await page.evaluate("window.clicked") is None
+    assert error
     assert "Element is not attached to the DOM" in error.message
 
 
-async def test_fail_when_element_detaches_after_animation(page, server):
+async def test_fail_when_element_detaches_after_animation(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/animating-button.html")
     await page.evaluate("addButton()")
     handle = await page.query_selector("button")
+    assert handle
     promise = asyncio.create_task(handle.click())
     await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
     await page.evaluate("stopButton(true)")
@@ -817,12 +886,14 @@ async def test_fail_when_element_detaches_after_animation(page, server):
     assert "Element is not attached to the DOM" in exc_info.value.message
 
 
-async def test_retry_when_element_detaches_after_animation(page, server):
+async def test_retry_when_element_detaches_after_animation(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/animating-button.html")
     await page.evaluate("addButton()")
     clicked = []
 
-    async def click():
+    async def click() -> None:
         await page.click("button")
         clicked.append(True)
 
@@ -844,7 +915,9 @@ async def click():
     assert await page.evaluate("window.clicked")
 
 
-async def test_retry_when_element_is_animating_from_outside_the_viewport(page, server):
+async def test_retry_when_element_is_animating_from_outside_the_viewport(
+    page: Page, server: Server
+) -> None:
     await page.set_content(
         """<style>
         @keyframes move {
@@ -868,6 +941,7 @@ async def test_retry_when_element_is_animating_from_outside_the_viewport(page, s
         """
     )
     handle = await page.query_selector("button")
+    assert handle
     promise = asyncio.create_task(handle.click())
     await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
     await handle.evaluate("button => button.className = 'animated'")
@@ -876,8 +950,8 @@ async def test_retry_when_element_is_animating_from_outside_the_viewport(page, s
 
 
 async def test_fail_when_element_is_animating_from_outside_the_viewport_with_force(
-    page, server
-):
+    page: Page,
+) -> None:
     await page.set_content(
         """<style>
         @keyframes move {
@@ -901,19 +975,23 @@ async def test_fail_when_element_is_animating_from_outside_the_viewport_with_for
         """
     )
     handle = await page.query_selector("button")
+    assert handle
     promise = asyncio.create_task(handle.click(force=True))
     await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
     await handle.evaluate("button => button.className = 'animated'")
-    error = None
+    error: Optional[Error] = None
     try:
         await promise
     except Error as e:
         error = e
     assert await page.evaluate("window.clicked") is None
+    assert error
     assert "Element is outside of the viewport" in error.message
 
 
-async def test_not_retarget_when_element_changes_on_hover(page, server):
+async def test_not_retarget_when_element_changes_on_hover(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/react.html")
     await page.evaluate(
         """() => {
@@ -925,7 +1003,9 @@ async def test_not_retarget_when_element_changes_on_hover(page, server):
     assert await page.evaluate("window.button2") is None
 
 
-async def test_not_retarget_when_element_is_recycled_on_hover(page, server):
+async def test_not_retarget_when_element_is_recycled_on_hover(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/react.html")
     await page.evaluate(
         """() => {
@@ -941,14 +1021,16 @@ async def test_not_retarget_when_element_is_recycled_on_hover(page, server):
     assert await page.evaluate("window.button2")
 
 
-async def test_click_the_button_when_window_inner_width_is_corrupted(page, server):
+async def test_click_the_button_when_window_inner_width_is_corrupted(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.evaluate("window.innerWidth = 0")
     await page.click("button")
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_timeout_when_click_opens_alert(page, server):
+async def test_timeout_when_click_opens_alert(page: Page, server: Server) -> None:
     await page.set_content('<div onclick="window.alert(123)">Click me</div>')
     async with page.expect_event("dialog") as dialog_info:
         with pytest.raises(Error) as exc_info:
@@ -958,31 +1040,31 @@ async def test_timeout_when_click_opens_alert(page, server):
     await dialog.dismiss()
 
 
-async def test_check_the_box(page):
+async def test_check_the_box(page: Page) -> None:
     await page.set_content('<input id="checkbox" type="checkbox"></input>')
     await page.check("input")
     assert await page.evaluate("checkbox.checked")
 
 
-async def test_not_check_the_checked_box(page):
+async def test_not_check_the_checked_box(page: Page) -> None:
     await page.set_content('<input id="checkbox" type="checkbox" checked></input>')
     await page.check("input")
     assert await page.evaluate("checkbox.checked")
 
 
-async def test_uncheck_the_box(page):
+async def test_uncheck_the_box(page: Page) -> None:
     await page.set_content('<input id="checkbox" type="checkbox" checked></input>')
     await page.uncheck("input")
     assert await page.evaluate("checkbox.checked") is False
 
 
-async def test_not_uncheck_the_unchecked_box(page):
+async def test_not_uncheck_the_unchecked_box(page: Page) -> None:
     await page.set_content('<input id="checkbox" type="checkbox"></input>')
     await page.uncheck("input")
     assert await page.evaluate("checkbox.checked") is False
 
 
-async def test_check_the_box_by_label(page):
+async def test_check_the_box_by_label(page: Page) -> None:
     await page.set_content(
         '<label for="checkbox"><input id="checkbox" type="checkbox"></input></label>'
     )
@@ -990,7 +1072,7 @@ async def test_check_the_box_by_label(page):
     assert await page.evaluate("checkbox.checked")
 
 
-async def test_check_the_box_outside_label(page):
+async def test_check_the_box_outside_label(page: Page) -> None:
     await page.set_content(
         '<label for="checkbox">Text</label><div><input id="checkbox" type="checkbox"></input></div>'
     )
@@ -998,7 +1080,7 @@ async def test_check_the_box_outside_label(page):
     assert await page.evaluate("checkbox.checked")
 
 
-async def test_check_the_box_inside_label_without_id(page):
+async def test_check_the_box_inside_label_without_id(page: Page) -> None:
     await page.set_content(
         '<label>Text<span><input id="checkbox" type="checkbox"></input></span></label>'
     )
@@ -1006,7 +1088,7 @@ async def test_check_the_box_inside_label_without_id(page):
     assert await page.evaluate("checkbox.checked")
 
 
-async def test_check_radio(page):
+async def test_check_radio(page: Page) -> None:
     await page.set_content(
         """
         <input type='radio'>one</input>
@@ -1017,7 +1099,7 @@ async def test_check_radio(page):
     assert await page.evaluate("two.checked")
 
 
-async def test_check_the_box_by_aria_role(page):
+async def test_check_the_box_by_aria_role(page: Page) -> None:
     await page.set_content(
         """<div role='checkbox' id='checkbox'>CHECKBOX</div>
         <script>
@@ -1026,3 +1108,40 @@ async def test_check_the_box_by_aria_role(page):
     )
     await page.check("div")
     assert await page.evaluate("checkbox.getAttribute ('aria-checked')")
+
+
+async def test_click_with_tweened_mouse_movement(page: Page, browser_name: str) -> None:
+    await page.set_content(
+        """
+        <body style="margin: 0; padding: 0; height: 500px; width: 500px;">
+          <div style="position: relative; top: 280px; left: 150px; width: 100px; height: 40px">Click me</div>
+        </body>
+        """
+    )
+
+    # The test becomes flaky on WebKit without next line.
+    if browser_name == "webkit":
+        await page.evaluate("() => new Promise(requestAnimationFrame)")
+    await page.mouse.move(100, 100)
+    await page.evaluate(
+        """() => {
+        window.result = [];
+        document.addEventListener('mousemove', event => {
+          window.result.push([event.clientX, event.clientY]);
+        });
+      }"""
+    )
+    # Centerpoint at 150 + 100/2, 280 + 40/2 = 200, 300
+    await page.locator("div").click(steps=5)
+    assert await page.evaluate("result") == [
+        [120, 140],
+        [140, 180],
+        [160, 220],
+        [180, 260],
+        [200, 300],
+    ]
+
+
+async def test_click_should_accept_timedelta_for_timeout(page: Page) -> None:
+    with pytest.raises(TimeoutError, match="Timeout 1ms exceeded"):
+        await page.click("does-not-exist", timeout=timedelta(milliseconds=1))
diff --git a/tests/async/test_console.py b/tests/async/test_console.py
index 1ccfe293e..737144412 100644
--- a/tests/async/test_console.py
+++ b/tests/async/test_console.py
@@ -12,37 +12,40 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import asyncio
 from typing import List
 
+import pytest
+
 from playwright.async_api import ConsoleMessage, Page
+from tests.server import Server
 
 
-async def test_console_should_work(page: Page, server):
+async def test_console_should_work(page: Page, browser_name: str) -> None:
     messages: List[ConsoleMessage] = []
     page.once("console", lambda m: messages.append(m))
-    await asyncio.gather(
-        page.evaluate('() => console.log("hello", 5, {foo: "bar"})'),
-        page.wait_for_event("console"),
-    )
-    assert len(messages) == 1
-    message = messages[0]
-    assert message.text == "hello 5 JSHandle@object"
-    assert str(message) == "hello 5 JSHandle@object"
+    async with page.expect_console_message() as message_info:
+        await page.evaluate('() => console.log("hello", 5, {foo: "bar"})')
+    message = await message_info.value
+    if browser_name != "firefox":
+        assert message.text == "hello 5 {foo: bar}"
+        assert str(message) == "hello 5 {foo: bar}"
+    else:
+        assert message.text == "hello 5 JSHandle@object"
+        assert str(message) == "hello 5 JSHandle@object"
     assert message.type == "log"
     assert await message.args[0].json_value() == "hello"
     assert await message.args[1].json_value() == 5
     assert await message.args[2].json_value() == {"foo": "bar"}
 
 
-async def test_console_should_emit_same_log_twice(page, server):
+async def test_console_should_emit_same_log_twice(page: Page) -> None:
     messages = []
     page.on("console", lambda m: messages.append(m.text))
     await page.evaluate('() => { for (let i = 0; i < 2; ++i ) console.log("hello"); } ')
     assert messages == ["hello", "hello"]
 
 
-async def test_console_should_use_text_for__str__(page):
+async def test_console_should_use_text_for__str__(page: Page) -> None:
     messages = []
     page.on("console", lambda m: messages.append(m))
     await page.evaluate('() => console.log("Hello world")')
@@ -50,8 +53,8 @@ async def test_console_should_use_text_for__str__(page):
     assert str(messages[0]) == "Hello world"
 
 
-async def test_console_should_work_for_different_console_api_calls(page, server):
-    messages = []
+async def test_console_should_work_for_different_console_api_calls(page: Page) -> None:
+    messages: List[ConsoleMessage] = []
     page.on("console", lambda m: messages.append(m))
     # All console events will be reported before 'page.evaluate' is finished.
     await page.evaluate(
@@ -81,72 +84,72 @@ async def test_console_should_work_for_different_console_api_calls(page, server)
         "calling console.dir",
         "calling console.warn",
         "calling console.error",
-        "JSHandle@promise",
+        "Promise",
     ]
 
 
-async def test_console_should_not_fail_for_window_object(page, server):
-    messages = []
-    page.once("console", lambda m: messages.append(m))
-    await asyncio.gather(
-        page.evaluate("() => console.error(window)"), page.wait_for_event("console")
-    )
-    assert len(messages) == 1
-    assert messages[0].text == "JSHandle@object"
+async def test_console_should_not_fail_for_window_object(
+    page: Page, browser_name: str
+) -> None:
+    async with page.expect_console_message() as message_info:
+        await page.evaluate("console.error(window)")
+    message = await message_info.value
+    if browser_name != "firefox":
+        assert message.text == "Window"
+    else:
+        assert message.text == "JSHandle@object"
 
 
-async def test_console_should_trigger_correct_Log(page, server):
+# Upstream issue https://bugs.webkit.org/show_bug.cgi?id=229515
+@pytest.mark.skip_browser("webkit")
+async def test_console_should_trigger_correct_log(page: Page, server: Server) -> None:
     await page.goto("about:blank")
-    message = (
-        await asyncio.gather(
-            page.wait_for_event("console"),
-            page.evaluate("async url => fetch(url).catch(e => {})", server.EMPTY_PAGE),
-        )
-    )[0]
-    assert "Access-Control-Allow-Origin" in message.text
+    async with page.expect_console_message() as message_info:
+        await page.evaluate("async url => fetch(url).catch(e => {})", server.EMPTY_PAGE)
+    message = await message_info.value
+    assert "Access-Control-Allow-Origin" in message.text or "CORS" in message.text
     assert message.type == "error"
 
 
-async def test_console_should_have_location_for_console_api_calls(page, server):
+async def test_console_should_have_location_for_console_api_calls(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
-    message = (
-        await asyncio.gather(
-            page.wait_for_event("console"),
-            page.goto(server.PREFIX + "/consolelog.html"),
-        )
-    )[0]
+    async with page.expect_console_message() as message_info:
+        await page.goto(server.PREFIX + "/consolelog.html")
+    message = await message_info.value
     assert message.text == "yellow"
     assert message.type == "log"
     location = message.location
     # Engines have different column notion.
-    assert location.url == server.PREFIX + "/consolelog.html"
-    assert location.line == 7
+    assert location["url"] == server.PREFIX + "/consolelog.html"
+    assert location["lineNumber"] == 7
+    # Added in 1.60: location now also exposes line/column aliases for parity with WebError.location.
+    assert location["line"] == 7
+    assert location["column"] == location["columnNumber"]
 
 
 async def test_console_should_not_throw_when_there_are_console_messages_in_detached_iframes(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.evaluate(
-                """async() => {
-                    // 1. Create a popup that Playwright is not connected to.
-                    const win = window.open('');
-                    window._popup = win;
-                    if (window.document.readyState !== 'complete')
-                    await new Promise(f => window.addEventListener('load', f));
-                    // 2. In this popup, create an iframe that console.logs a message.
-                    win.document.body.innerHTML = `<iframe src='/consolelog.html'></iframe>`;
-                    const frame = win.document.querySelector('iframe');
-                    if (!frame.contentDocument || frame.contentDocument.readyState !== 'complete')
-                    await new Promise(f => frame.addEventListener('load', f));
-                    // 3. After that, remove the iframe.
-                    frame.remove();
-                }"""
-            ),
+    async with page.expect_popup() as page_info:
+        await page.evaluate(
+            """async() => {
+                // 1. Create a popup that Playwright is not connected to.
+                const win = window.open('');
+                window._popup = win;
+                if (window.document.readyState !== 'complete')
+                await new Promise(f => window.addEventListener('load', f));
+                // 2. In this popup, create an iframe that console.logs a message.
+                win.document.body.innerHTML = `<iframe src='/consolelog.html'></iframe>`;
+                const frame = win.document.querySelector('iframe');
+                if (!frame.contentDocument || frame.contentDocument.readyState !== 'complete')
+                await new Promise(f => frame.addEventListener('load', f));
+                // 3. After that, remove the iframe.
+                frame.remove();
+            }"""
         )
-    )[0]
+    popup = await page_info.value
     # 4. Connect to the popup and make sure it doesn't throw.
     assert await popup.evaluate("1 + 1") == 2
diff --git a/tests/async/test_context_manager.py b/tests/async/test_context_manager.py
new file mode 100644
index 000000000..f54263157
--- /dev/null
+++ b/tests/async/test_context_manager.py
@@ -0,0 +1,38 @@
+# 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.
+
+from typing import Dict
+
+import pytest
+
+from playwright.async_api import BrowserContext, BrowserType
+
+
+async def test_context_managers(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
+    async with await browser_type.launch(**launch_arguments) as browser:
+        async with await browser.new_context() as context:
+            async with await context.new_page():
+                assert len(context.pages) == 1
+            assert len(context.pages) == 0
+            assert len(browser.contexts) == 1
+        assert len(browser.contexts) == 0
+    assert not browser.is_connected()
+
+
+async def test_context_managers_not_hang(context: BrowserContext) -> None:
+    with pytest.raises(Exception, match="Oops!"):
+        async with await context.new_page():
+            raise Exception("Oops!")
diff --git a/tests/async/test_debugger.py b/tests/async/test_debugger.py
new file mode 100644
index 000000000..9613fcb34
--- /dev/null
+++ b/tests/async/test_debugger.py
@@ -0,0 +1,43 @@
+# 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 asyncio
+
+from playwright.async_api import BrowserContext, Page
+from tests.server import Server
+
+
+async def test_should_expose_debugger_property(context: BrowserContext) -> None:
+    assert context.debugger is context.debugger
+    assert context.debugger.paused_details is None
+
+
+async def test_should_pause_and_resume(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    paused_event = asyncio.Event()
+    context.debugger.on("pausedstatechanged", lambda: paused_event.set())
+
+    await context.debugger.request_pause()
+    next_call = asyncio.create_task(page.goto(server.EMPTY_PAGE))
+
+    await asyncio.wait_for(paused_event.wait(), timeout=5)
+    assert context.debugger.paused_details is not None
+
+    paused_event.clear()
+    await context.debugger.resume()
+    await asyncio.wait_for(paused_event.wait(), timeout=5)
+    assert context.debugger.paused_details is None
+
+    await next_call
diff --git a/tests/async/test_defaultbrowsercontext.py b/tests/async/test_defaultbrowsercontext.py
index a76bb39aa..f5d2a606d 100644
--- a/tests/async/test_defaultbrowsercontext.py
+++ b/tests/async/test_defaultbrowsercontext.py
@@ -14,31 +14,61 @@
 
 import asyncio
 import os
+from pathlib import Path
+from typing import (
+    Any,
+    AsyncGenerator,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    Tuple,
+)
 
 import pytest
-from flaky import flaky
 
-from playwright._impl._api_types import Error
+from playwright.async_api import (
+    BrowserContext,
+    BrowserType,
+    Cookie,
+    Error,
+    Page,
+    expect,
+)
+from tests.server import Server
+from tests.utils import must
+
+from .utils import Utils
 
 
 @pytest.fixture()
-async def launch_persistent(tmpdir, launch_arguments, browser_type):
-    context = None
+async def launch_persistent(
+    tmp_path: Path, launch_arguments: Dict, browser_type: BrowserType
+) -> AsyncGenerator[Callable[..., Awaitable[Tuple[Page, BrowserContext]]], None]:
+    context: Optional[BrowserContext] = None
 
-    async def _launch(**options):
+    async def _launch(**options: Any) -> Tuple[Page, BrowserContext]:
         nonlocal context
         if context:
-            raise ValueError("can only launch one persitent context")
+            raise ValueError("can only launch one persistent context")
         context = await browser_type.launch_persistent_context(
-            str(tmpdir), **{**launch_arguments, **options}
+            str(tmp_path), **{**launch_arguments, **options}
         )
+        assert context
         return (context.pages[0], context)
 
     yield _launch
-    await context.close()
+    await must(context).close()
 
 
-async def test_context_cookies_should_work(server, launch_persistent, is_firefox):
+async def test_context_cookies_should_work(
+    server: Server,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+    default_same_site_cookie_value: str,
+) -> None:
     (page, context) = await launch_persistent()
     await page.goto(server.EMPTY_PAGE)
     document_cookie = await page.evaluate(
@@ -49,7 +79,7 @@ async def test_context_cookies_should_work(server, launch_persistent, is_firefox
     )
 
     assert document_cookie == "username=John Doe"
-    assert await page.context.cookies() == [
+    assert _filter_cookies(await page.context.cookies()) == [
         {
             "name": "username",
             "value": "John Doe",
@@ -58,19 +88,30 @@ async def test_context_cookies_should_work(server, launch_persistent, is_firefox
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
 
-async def test_context_add_cookies_should_work(server, launch_persistent):
+async def test_context_add_cookies_should_work(
+    server: Server,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+    default_same_site_cookie_value: Literal["Lax", "None", "Strict"],
+) -> None:
     (page, context) = await launch_persistent()
     await page.goto(server.EMPTY_PAGE)
     await page.context.add_cookies(
-        [{"url": server.EMPTY_PAGE, "name": "username", "value": "John Doe"}]
+        [
+            {
+                "url": server.EMPTY_PAGE,
+                "name": "username",
+                "value": "John Doe",
+                "sameSite": default_same_site_cookie_value,
+            }
+        ]
     )
     assert await page.evaluate("() => document.cookie") == "username=John Doe"
-    assert await page.context.cookies() == [
+    assert _filter_cookies(await page.context.cookies()) == [
         {
             "name": "username",
             "value": "John Doe",
@@ -79,12 +120,21 @@ async def test_context_add_cookies_should_work(server, launch_persistent):
             "expires": -1,
             "httpOnly": False,
             "secure": False,
-            "sameSite": "None",
+            "sameSite": default_same_site_cookie_value,
         }
     ]
 
 
-async def test_context_clear_cookies_should_work(server, launch_persistent):
+def _filter_cookies(cookies: Sequence[Cookie]) -> List[Cookie]:
+    return list(
+        filter(lambda cookie: not cookie["domain"].endswith("microsoft.com"), cookies)
+    )
+
+
+async def test_context_clear_cookies_should_work(
+    server: Server,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent()
     await page.goto(server.EMPTY_PAGE)
     await page.context.add_cookies(
@@ -96,13 +146,15 @@ async def test_context_clear_cookies_should_work(server, launch_persistent):
     assert await page.evaluate("document.cookie") == "cookie1=1; cookie2=2"
     await page.context.clear_cookies()
     await page.reload()
-    assert await page.context.cookies([]) == []
+    assert _filter_cookies(await page.context.cookies([])) == []
     assert await page.evaluate("document.cookie") == ""
 
 
 async def test_should_not_block_third_party_cookies(
-    server, launch_persistent, is_chromium, is_firefox
-):
+    server: Server,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+    is_firefox: bool,
+) -> None:
     (page, context) = await launch_persistent()
     await page.goto(server.EMPTY_PAGE)
     await page.evaluate(
@@ -125,7 +177,7 @@ async def test_should_not_block_third_party_cookies(
     )
 
     await page.wait_for_timeout(2000)
-    allows_third_party = is_chromium or is_firefox
+    allows_third_party = is_firefox
     assert document_cookie == ("username=John Doe" if allows_third_party else "")
     cookies = await context.cookies(server.CROSS_PROCESS_PREFIX + "/grid.html")
     if allows_third_party:
@@ -145,19 +197,27 @@ async def test_should_not_block_third_party_cookies(
         assert cookies == []
 
 
-async def test_should_support_viewport_option(launch_persistent, utils):
+async def test_should_support_viewport_option(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+    utils: Utils,
+) -> None:
     (page, context) = await launch_persistent(viewport={"width": 456, "height": 789})
     await utils.verify_viewport(page, 456, 789)
     page2 = await context.new_page()
     await utils.verify_viewport(page2, 456, 789)
 
 
-async def test_should_support_device_scale_factor_option(launch_persistent, utils):
+async def test_should_support_device_scale_factor_option(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent(device_scale_factor=3)
     assert await page.evaluate("window.devicePixelRatio") == 3
 
 
-async def test_should_support_user_agent_option(launch_persistent, server):
+async def test_should_support_user_agent_option(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+    server: Server,
+) -> None:
     (page, context) = await launch_persistent(user_agent="foobar")
     assert await page.evaluate("() => navigator.userAgent") == "foobar"
     [request, _] = await asyncio.gather(
@@ -167,14 +227,20 @@ async def test_should_support_user_agent_option(launch_persistent, server):
     assert request.getHeader("user-agent") == "foobar"
 
 
-async def test_should_support_bypass_csp_option(launch_persistent, server):
+async def test_should_support_bypass_csp_option(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+    server: Server,
+) -> None:
     (page, context) = await launch_persistent(bypass_csp=True)
     await page.goto(server.PREFIX + "/csp.html")
     await page.add_script_tag(content="window.__injected = 42;")
     assert await page.evaluate("() => window.__injected") == 42
 
 
-async def test_should_support_javascript_enabled_option(launch_persistent, is_webkit):
+async def test_should_support_javascript_enabled_option(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+    is_webkit: bool,
+) -> None:
     (page, context) = await launch_persistent(java_script_enabled=False)
     await page.goto('data:text/html, <script>var something = "forbidden"</script>')
     with pytest.raises(Error) as exc:
@@ -185,29 +251,42 @@ async def test_should_support_javascript_enabled_option(launch_persistent, is_we
         assert "something is not defined" in exc.value.message
 
 
-async def test_should_support_http_credentials_option(server, launch_persistent):
+async def test_should_support_http_credentials_option(
+    server: Server,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent(
         http_credentials={"username": "user", "password": "pass"}
     )
-    server.set_auth("/playground.html", b"user", b"pass")
+    server.set_auth("/playground.html", "user", "pass")
     response = await page.goto(server.PREFIX + "/playground.html")
+    assert response
     assert response.status == 200
 
 
-async def test_should_support_offline_option(server, launch_persistent):
+async def test_should_support_offline_option(
+    server: Server,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent(offline=True)
     with pytest.raises(Error):
         await page.goto(server.EMPTY_PAGE)
 
 
-async def test_should_support_has_touch_option(server, launch_persistent):
+async def test_should_support_has_touch_option(
+    server: Server,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent(has_touch=True)
     await page.goto(server.PREFIX + "/mobile.html")
     assert await page.evaluate('() => "ontouchstart" in window')
 
 
 @pytest.mark.skip_browser("firefox")
-async def test_should_work_in_persistent_context(server, launch_persistent):
+async def test_should_work_in_persistent_context(
+    server: Server,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     # Firefox does not support mobile.
     (page, context) = await launch_persistent(
         viewport={"width": 320, "height": 480}, is_mobile=True
@@ -216,7 +295,9 @@ async def test_should_work_in_persistent_context(server, launch_persistent):
     assert await page.evaluate("() => window.innerWidth") == 980
 
 
-async def test_should_support_color_scheme_option(server, launch_persistent):
+async def test_should_support_color_scheme_option(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent(color_scheme="dark")
     assert (
         await page.evaluate('() => matchMedia("(prefers-color-scheme: light)").matches')
@@ -227,7 +308,9 @@ async def test_should_support_color_scheme_option(server, launch_persistent):
     )
 
 
-async def test_should_support_timezone_id_option(launch_persistent):
+async def test_should_support_timezone_id_option(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent(timezone_id="America/Jamaica")
     assert (
         await page.evaluate("() => new Date(1479579154987).toString()")
@@ -235,14 +318,27 @@ async def test_should_support_timezone_id_option(launch_persistent):
     )
 
 
-async def test_should_support_locale_option(launch_persistent):
-    (page, context) = await launch_persistent(locale="fr-CH")
-    assert await page.evaluate("() => navigator.language") == "fr-CH"
+async def test_should_support_contrast_option(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
+    (page, _) = await launch_persistent(contrast="more")
+    assert await page.evaluate('() => matchMedia("(prefers-contrast: more)").matches')
+    assert not await page.evaluate(
+        '() => matchMedia("(prefers-contrast: no-preference)").matches'
+    )
+
+
+async def test_should_support_locale_option(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
+    (page, context) = await launch_persistent(locale="fr-FR")
+    assert await page.evaluate("() => navigator.language") == "fr-FR"
 
 
 async def test_should_support_geolocation_and_permission_option(
-    server, launch_persistent
-):
+    server: Server,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent(
         geolocation={"longitude": 10, "latitude": 10}, permissions=["geolocation"]
     )
@@ -256,14 +352,19 @@ async def test_should_support_geolocation_and_permission_option(
 
 
 async def test_should_support_ignore_https_errors_option(
-    https_server, launch_persistent
-):
+    https_server: Server,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent(ignore_https_errors=True)
     response = await page.goto(https_server.EMPTY_PAGE)
+    assert response
     assert response.ok
 
 
-async def test_should_support_extra_http_headers_option(server, launch_persistent):
+async def test_should_support_extra_http_headers_option(
+    server: Server,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent(extra_http_headers={"foo": "bar"})
     [request, _] = await asyncio.gather(
         server.wait_for_request("/empty.html"),
@@ -272,18 +373,23 @@ async def test_should_support_extra_http_headers_option(server, launch_persisten
     assert request.getHeader("foo") == "bar"
 
 
-async def test_should_accept_user_data_dir(server, tmpdir, launch_persistent):
+async def test_should_accept_user_data_dir(
+    tmp_path: Path,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent()
     # Note: we need an open page to make sure its functional.
-    assert len(os.listdir(tmpdir)) > 0
+    assert len(os.listdir(tmp_path)) > 0
     await context.close()
-    assert len(os.listdir(tmpdir)) > 0
+    assert len(os.listdir(tmp_path)) > 0
 
 
-@flaky
 async def test_should_restore_state_from_userDataDir(
-    browser_type, launch_arguments, server, tmp_path_factory
-):
+    browser_type: BrowserType,
+    launch_arguments: Dict,
+    server: Server,
+    tmp_path_factory: pytest.TempPathFactory,
+) -> None:
     user_data_dir1 = tmp_path_factory.mktemp("test")
     browser_context = await browser_type.launch_persistent_context(
         user_data_dir1, **launch_arguments
@@ -311,52 +417,9 @@ async def test_should_restore_state_from_userDataDir(
     await browser_context3.close()
 
 
-async def test_should_restore_cookies_from_userDataDir(
-    browser_type,
-    launch_arguments,
-    tmp_path_factory,
-    server,
-    is_chromium,
-    is_win,
-    is_mac,
-):
-    if is_chromium and (is_win or is_mac):
-        pytest.skip()
-    userDataDir = tmp_path_factory.mktemp("1")
-    browser_context = await browser_type.launch_persistent_context(
-        userDataDir, **launch_arguments
-    )
-    page = await browser_context.new_page()
-    await page.goto(server.EMPTY_PAGE)
-    document_cookie = await page.evaluate(
-        """() => {
-    document.cookie = 'doSomethingOnlyOnce=true; expires=Fri, 31 Dec 9999 23:59:59 GMT';
-    return document.cookie;
-  }"""
-    )
-
-    assert document_cookie == "doSomethingOnlyOnce=true"
-    await browser_context.close()
-
-    browser_context2 = await browser_type.launch_persistent_context(
-        userDataDir, **launch_arguments
-    )
-    page2 = await browser_context2.new_page()
-    await page2.goto(server.EMPTY_PAGE)
-    assert await page2.evaluate("() => document.cookie") == "doSomethingOnlyOnce=true"
-    await browser_context2.close()
-
-    userDataDir2 = tmp_path_factory.mktemp("2")
-    browser_context3 = await browser_type.launch_persistent_context(
-        userDataDir2, **launch_arguments
-    )
-    page3 = await browser_context3.new_page()
-    await page3.goto(server.EMPTY_PAGE)
-    assert await page3.evaluate("() => document.cookie") != "doSomethingOnlyOnce=true"
-    await browser_context3.close()
-
-
-async def test_should_have_default_url_when_launching_browser(launch_persistent):
+async def test_should_have_default_url_when_launching_browser(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent()
     urls = list(map(lambda p: p.url, context.pages))
     assert urls == ["about:blank"]
@@ -364,17 +427,37 @@ async def test_should_have_default_url_when_launching_browser(launch_persistent)
 
 @pytest.mark.skip_browser("firefox")
 async def test_should_throw_if_page_argument_is_passed(
-    browser_type, server, tmpdir, launch_arguments
-):
+    browser_type: BrowserType, server: Server, tmp_path: Path, launch_arguments: Dict
+) -> None:
     options = {**launch_arguments, "args": [server.EMPTY_PAGE]}
     with pytest.raises(Error) as exc:
-        await browser_type.launch_persistent_context(tmpdir, **options)
+        await browser_type.launch_persistent_context(tmp_path, **options)
     assert "can not specify page" in exc.value.message
 
 
-async def test_should_fire_close_event_for_a_persistent_context(launch_persistent):
+async def test_should_fire_close_event_for_a_persistent_context(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
     (page, context) = await launch_persistent()
-    fired_event = asyncio.Future()
-    context.on("close", lambda: fired_event.set_result(True))
+    fired_event: "asyncio.Future[bool]" = asyncio.Future()
+    context.on("close", lambda _: fired_event.set_result(True))
     await context.close()
     await fired_event
+
+
+async def test_should_support_reduced_motion(
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
+    (page, context) = await launch_persistent(reduced_motion="reduce")
+    assert await page.evaluate("matchMedia('(prefers-reduced-motion: reduce)').matches")
+
+
+async def test_should_support_har_option(
+    assetdir: Path,
+    launch_persistent: "Callable[..., asyncio.Future[Tuple[Page, BrowserContext]]]",
+) -> None:
+    (page, context) = await launch_persistent()
+    await page.route_from_har(har=assetdir / "har-fulfill.har")
+    await page.goto("http://no.playwright/")
+    assert await page.evaluate("window.value") == "foo"
+    await expect(page.locator("body")).to_have_css("background-color", "rgb(255, 0, 0)")
diff --git a/tests/async/test_device_descriptors.py b/tests/async/test_device_descriptors.py
new file mode 100644
index 000000000..f14fc1ffd
--- /dev/null
+++ b/tests/async/test_device_descriptors.py
@@ -0,0 +1,54 @@
+# 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.
+from typing import Dict
+
+import pytest
+
+from playwright.async_api import Playwright
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_work(playwright: Playwright, launch_arguments: Dict) -> None:
+    device_descriptor = playwright.devices["Pixel 2"]
+    device_type = device_descriptor["default_browser_type"]
+    browser = await playwright[device_type].launch(**launch_arguments)
+    context = await browser.new_context(
+        **device_descriptor,
+    )
+    page = await context.new_page()
+    assert device_descriptor["default_browser_type"] == "chromium"
+    assert browser.browser_type.name == "chromium"
+
+    assert "Pixel 2" in device_descriptor["user_agent"]
+    assert "Pixel 2" in await page.evaluate("navigator.userAgent")
+
+    assert device_descriptor["device_scale_factor"] > 2
+    assert await page.evaluate("window.devicePixelRatio") > 2
+
+    assert device_descriptor["viewport"]["height"] > 700
+    assert device_descriptor["viewport"]["height"] < 800
+    inner_height = await page.evaluate("window.screen.availHeight")
+    assert inner_height > 700
+    assert inner_height < 800
+
+    assert device_descriptor["viewport"]["width"] > 400
+    assert device_descriptor["viewport"]["width"] < 500
+    inner_width = await page.evaluate("window.screen.availWidth")
+    assert inner_width > 400
+    assert inner_width < 500
+
+    assert device_descriptor["has_touch"]
+    assert device_descriptor["is_mobile"]
+
+    await browser.close()
diff --git a/tests/async/test_dialog.py b/tests/async/test_dialog.py
index 8479bc29e..a25c6468f 100644
--- a/tests/async/test_dialog.py
+++ b/tests/async/test_dialog.py
@@ -12,17 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import asyncio
+from playwright.async_api import Browser, Dialog, Page
 
-import pytest
 
-from playwright.async_api import Dialog, Page
-
-
-async def test_should_fire(page: Page, server):
+async def test_should_fire(page: Page) -> None:
     result = []
 
-    async def on_dialog(dialog: Dialog):
+    async def on_dialog(dialog: Dialog) -> None:
         result.append(True)
         assert dialog.type == "alert"
         assert dialog.default_value == ""
@@ -34,10 +30,10 @@ async def on_dialog(dialog: Dialog):
     assert result
 
 
-async def test_should_allow_accepting_prompts(page: Page, server):
+async def test_should_allow_accepting_prompts(page: Page) -> None:
     result = []
 
-    async def on_dialog(dialog: Dialog):
+    async def on_dialog(dialog: Dialog) -> None:
         result.append(True)
         assert dialog.type == "prompt"
         assert dialog.default_value == "yes."
@@ -49,10 +45,10 @@ async def on_dialog(dialog: Dialog):
     assert result
 
 
-async def test_should_dismiss_the_prompt(page: Page, server):
+async def test_should_dismiss_the_prompt(page: Page) -> None:
     result = []
 
-    async def on_dialog(dialog: Dialog):
+    async def on_dialog(dialog: Dialog) -> None:
         result.append(True)
         await dialog.dismiss()
 
@@ -61,10 +57,10 @@ async def on_dialog(dialog: Dialog):
     assert result
 
 
-async def test_should_accept_the_confirm_prompt(page: Page, server):
+async def test_should_accept_the_confirm_prompt(page: Page) -> None:
     result = []
 
-    async def on_dialog(dialog: Dialog):
+    async def on_dialog(dialog: Dialog) -> None:
         result.append(True)
         await dialog.accept()
 
@@ -73,10 +69,10 @@ async def on_dialog(dialog: Dialog):
     assert result
 
 
-async def test_should_dismiss_the_confirm_prompt(page: Page, server):
+async def test_should_dismiss_the_confirm_prompt(page: Page) -> None:
     result = []
 
-    async def on_dialog(dialog: Dialog):
+    async def on_dialog(dialog: Dialog) -> None:
         result.append(True)
         await dialog.dismiss()
 
@@ -85,31 +81,36 @@ async def on_dialog(dialog: Dialog):
     assert result
 
 
-# TODO: Logger support not yet here
-# //   it.fail(CHANNEL)('should log prompt actions', async({browser}) => {
-# //     const messages = [];
-# //     const context = await browser.new_context({
-# //       logger: {
-# //         isEnabled: () => true,
-# //         log: (name, severity, message) => messages.push(message),
-# //       }
-# //     });
-# //     const page = await context.new_page();
-# //     const promise = page.evaluate(() => confirm('01234567890123456789012345678901234567890123456789012345678901234567890123456789'));
-# //     const dialog = await page.wait_for_event('dialog');
-# //     expect(messages.join()).toContain('confirm "0123456789012345678901234567890123456789012345678…" was shown');
-# //     await dialog.accept('123');
-# //     await promise;
-# //     expect(messages.join()).toContain('confirm "0123456789012345678901234567890123456789012345678…" was accepted');
-# //     await context.close();
-# //   });
-
-
-@pytest.mark.skip_browser("webkit")
-async def test_should_be_able_to_close_context_with_open_alert(browser):
+async def test_should_be_able_to_close_context_with_open_alert(
+    browser: Browser,
+) -> None:
+    context = await browser.new_context()
+    page = await context.new_page()
+    async with page.expect_event("dialog"):
+        await page.evaluate("() => setTimeout(() => alert('hello'), 0)", None)
+    await context.close()
+
+
+async def test_should_auto_dismiss_the_prompt_without_listeners(page: Page) -> None:
+    result = await page.evaluate('() => prompt("question?")')
+    assert not result
+
+
+async def test_should_auto_dismiss_the_alert_without_listeners(page: Page) -> None:
+    await page.set_content(
+        '<div onclick="window.alert(123); window._clicked=true">Click me</div>'
+    )
+    await page.click("div")
+    assert await page.evaluate('"window._clicked"')
+
+
+async def test_dismiss_should_swallow_target_closed_error(browser: Browser) -> None:
     context = await browser.new_context()
     page = await context.new_page()
-    alertFuture = asyncio.create_task(page.wait_for_event("dialog"))
-    await page.evaluate("() => setTimeout(() => alert('hello'), 0)", None)
-    await alertFuture
+    async with page.expect_event("dialog") as dialog_info:
+        await page.evaluate("() => setTimeout(() => alert('hello'), 0)", None)
+    dialog = await dialog_info.value
+    await page.close()
+    # Dialog.dismiss should be a no-op once the target is closed.
+    await dialog.dismiss()
     await context.close()
diff --git a/tests/async/test_dispatch_event.py b/tests/async/test_dispatch_event.py
index dd80df45f..50b02ba2e 100644
--- a/tests/async/test_dispatch_event.py
+++ b/tests/async/test_dispatch_event.py
@@ -12,16 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import pytest
 
+from playwright.async_api import Page, Selectors
+from tests.server import Server
 
-async def test_should_dispatch_click_event(page, server):
+from .utils import Utils
+
+
+async def test_should_dispatch_click_event(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.dispatch_event("button", "click")
     assert await page.evaluate("() => result") == "Clicked"
 
 
-async def test_should_dispatch_click_event_properties(page, server):
+async def test_should_dispatch_click_event_properties(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.dispatch_event("button", "click")
     assert await page.evaluate("() => bubbles")
@@ -29,7 +35,7 @@ async def test_should_dispatch_click_event_properties(page, server):
     assert await page.evaluate("() => composed")
 
 
-async def test_should_dispatch_click_svg(page):
+async def test_should_dispatch_click_svg(page: Page) -> None:
     await page.set_content(
         """
       <svg height="100" width="100">
@@ -41,7 +47,9 @@ async def test_should_dispatch_click_svg(page):
     assert await page.evaluate("() => window.__CLICKED") == 42
 
 
-async def test_should_dispatch_click_on_a_span_with_an_inline_element_inside(page):
+async def test_should_dispatch_click_on_a_span_with_an_inline_element_inside(
+    page: Page,
+) -> None:
     await page.set_content(
         """
       <style>
@@ -56,7 +64,9 @@ async def test_should_dispatch_click_on_a_span_with_an_inline_element_inside(pag
     assert await page.evaluate("() => window.CLICKED") == 42
 
 
-async def test_should_dispatch_click_after_navigation(page, server):
+async def test_should_dispatch_click_after_navigation(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.dispatch_event("button", "click")
     await page.goto(server.PREFIX + "/input/button.html")
@@ -64,7 +74,9 @@ async def test_should_dispatch_click_after_navigation(page, server):
     assert await page.evaluate("() => result") == "Clicked"
 
 
-async def test_should_dispatch_click_after_a_cross_origin_navigation(page, server):
+async def test_should_dispatch_click_after_a_cross_origin_navigation(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.dispatch_event("button", "click")
     await page.goto(server.CROSS_PROCESS_PREFIX + "/input/button.html")
@@ -72,7 +84,7 @@ async def test_should_dispatch_click_after_a_cross_origin_navigation(page, serve
     assert await page.evaluate("() => result") == "Clicked"
 
 
-async def test_should_not_fail_when_element_is_blocked_on_hover(page, server):
+async def test_should_not_fail_when_element_is_blocked_on_hover(page: Page) -> None:
     await page.set_content(
         """<style>
       container { display: block; position: relative; width: 200px; height: 50px; }
@@ -89,7 +101,9 @@ async def test_should_not_fail_when_element_is_blocked_on_hover(page, server):
     assert await page.evaluate("() => window.clicked")
 
 
-async def test_should_dispatch_click_when_node_is_added_in_shadow_dom(page, server):
+async def test_should_dispatch_click_when_node_is_added_in_shadow_dom(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     watchdog = page.dispatch_event("span", "click")
     await page.evaluate(
@@ -112,7 +126,7 @@ async def test_should_dispatch_click_when_node_is_added_in_shadow_dom(page, serv
     assert await page.evaluate("() => window.clicked")
 
 
-async def test_should_be_atomic(selectors, page, utils):
+async def test_should_be_atomic(selectors: Selectors, page: Page, utils: Utils) -> None:
     await utils.register_selector_engine(
         selectors,
         "dispatch_event",
@@ -137,8 +151,7 @@ async def test_should_be_atomic(selectors, page, utils):
     assert await page.evaluate("() => window._clicked")
 
 
-@pytest.mark.skip_browser("webkit")
-async def test_should_dispatch_drag_drop_events(page, server):
+async def test_should_dispatch_drag_drop_events(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/drag-n-drop.html")
     dataTransfer = await page.evaluate_handle("() => new DataTransfer()")
     await page.dispatch_event("#source", "dragstart", {"dataTransfer": dataTransfer})
@@ -150,13 +163,16 @@ async def test_should_dispatch_drag_drop_events(page, server):
     )
 
 
-@pytest.mark.skip_browser("webkit")
-async def test_should_dispatch_drag_and_drop_events_element_handle(page, server):
+async def test_should_dispatch_drag_and_drop_events_element_handle(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/drag-n-drop.html")
     dataTransfer = await page.evaluate_handle("() => new DataTransfer()")
     source = await page.query_selector("#source")
+    assert source
     await source.dispatch_event("dragstart", {"dataTransfer": dataTransfer})
     target = await page.query_selector("#target")
+    assert target
     await target.dispatch_event("drop", {"dataTransfer": dataTransfer})
     assert await page.evaluate(
         """() => {
@@ -165,8 +181,11 @@ async def test_should_dispatch_drag_and_drop_events_element_handle(page, server)
     )
 
 
-async def test_should_dispatch_click_event_element_handle(page, server):
+async def test_should_dispatch_click_event_element_handle(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     button = await page.query_selector("button")
+    assert button
     await button.dispatch_event("click")
     assert await page.evaluate("() => result") == "Clicked"
diff --git a/tests/async/test_download.py b/tests/async/test_download.py
index 4a932733e..6b0d6be1a 100644
--- a/tests/async/test_download.py
+++ b/tests/async/test_download.py
@@ -15,27 +15,29 @@
 import os
 from asyncio.futures import Future
 from pathlib import Path
-from typing import Optional
+from typing import Callable, Generator
 
 import pytest
 
-from playwright.async_api import Browser, Error, Page
+from playwright.async_api import Browser, Download, Error, Page
+from tests.server import Server, TestServerRequest
+from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
 
 
-def assert_file_content(path, content):
+def assert_file_content(path: Path, content: str) -> None:
     with open(path, "r") as fd:
         assert fd.read() == content
 
 
 @pytest.fixture(autouse=True)
-def after_each_hook(server):
-    def handle_download(request):
+def after_each_hook(server: Server) -> Generator[None, None, None]:
+    def handle_download(request: TestServerRequest) -> None:
         request.setHeader("Content-Type", "application/octet-stream")
         request.setHeader("Content-Disposition", "attachment")
         request.write(b"Hello world")
         request.finish()
 
-    def handle_download_with_file_name(request):
+    def handle_download_with_file_name(request: TestServerRequest) -> None:
         request.setHeader("Content-Type", "application/octet-stream")
         request.setHeader("Content-Disposition", "attachment; filename=file.txt")
         request.write(b"Hello world")
@@ -46,44 +48,49 @@ def handle_download_with_file_name(request):
     yield
 
 
-async def test_should_report_downloads_with_accept_downloads_false(page: Page, server):
+async def test_should_report_downloads_with_accept_downloads_false(
+    page: Page, server: Server
+) -> None:
     await page.set_content(
         f'<a href="{server.PREFIX}/downloadWithFilename">download</a>'
     )
-    download = (await asyncio.gather(page.wait_for_event("download"), page.click("a")))[
-        0
-    ]
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
+    assert download.page is page
     assert download.url == f"{server.PREFIX}/downloadWithFilename"
     assert download.suggested_filename == "file.txt"
-    error: Optional[Error] = None
-    try:
-        await download.path()
-    except Error as exc:
-        error = exc
-    assert "accept_downloads" in await download.failure()
-    assert error
-    assert "accept_downloads: True" in error.message
+    assert (
+        repr(download)
+        == f"<Download url={download.url!r} suggested_filename={download.suggested_filename!r}>"
+    )
+    assert await download.path()
+    assert await download.failure() is None
 
 
-async def test_should_report_downloads_with_accept_downloads_true(browser, server):
+async def test_should_report_downloads_with_accept_downloads_true(
+    browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    download = (await asyncio.gather(page.wait_for_event("download"), page.click("a")))[
-        0
-    ]
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
     path = await download.path()
     assert os.path.isfile(path)
     assert_file_content(path, "Hello world")
     await page.close()
 
 
-async def test_should_save_to_user_specified_path(tmpdir: Path, browser, server):
+async def test_should_save_to_user_specified_path(
+    tmp_path: Path, browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    [download, _] = await asyncio.gather(
-        page.wait_for_event("download"), page.click("a")
-    )
-    user_path = tmpdir / "download.txt"
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
+    user_path = tmp_path / "download.txt"
     await download.save_as(user_path)
     assert user_path.exists()
     assert user_path.read_text("utf-8") == "Hello world"
@@ -91,14 +98,14 @@ async def test_should_save_to_user_specified_path(tmpdir: Path, browser, server)
 
 
 async def test_should_save_to_user_specified_path_without_updating_original_path(
-    tmpdir, browser, server
-):
+    tmp_path: Path, browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    [download, _] = await asyncio.gather(
-        page.wait_for_event("download"), page.click("a")
-    )
-    user_path = tmpdir / "download.txt"
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
+    user_path = tmp_path / "download.txt"
     await download.save_as(user_path)
     assert user_path.exists()
     assert user_path.read_text("utf-8") == "Hello world"
@@ -110,50 +117,52 @@ async def test_should_save_to_user_specified_path_without_updating_original_path
 
 
 async def test_should_save_to_two_different_paths_with_multiple_save_as_calls(
-    tmpdir, browser, server
-):
+    tmp_path: Path, browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    [download, _] = await asyncio.gather(
-        page.wait_for_event("download"), page.click("a")
-    )
-    user_path = tmpdir / "download.txt"
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
+    user_path = tmp_path / "download.txt"
     await download.save_as(user_path)
     assert user_path.exists()
     assert user_path.read_text("utf-8") == "Hello world"
 
-    anotheruser_path = tmpdir / "download (2).txt"
+    anotheruser_path = tmp_path / "download (2).txt"
     await download.save_as(anotheruser_path)
     assert anotheruser_path.exists()
     assert anotheruser_path.read_text("utf-8") == "Hello world"
     await page.close()
 
 
-async def test_should_save_to_overwritten_filepath(tmpdir: Path, browser, server):
+async def test_should_save_to_overwritten_filepath(
+    tmp_path: Path, browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    [download, _] = await asyncio.gather(
-        page.wait_for_event("download"), page.click("a")
-    )
-    user_path = tmpdir / "download.txt"
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
+    user_path = tmp_path / "download.txt"
     await download.save_as(user_path)
-    assert len(list(Path(tmpdir).glob("*.*"))) == 1
+    assert len(list(tmp_path.glob("*.*"))) == 1
     await download.save_as(user_path)
-    assert len(list(Path(tmpdir).glob("*.*"))) == 1
+    assert len(list(tmp_path.glob("*.*"))) == 1
     assert user_path.exists()
     assert user_path.read_text("utf-8") == "Hello world"
     await page.close()
 
 
 async def test_should_create_subdirectories_when_saving_to_non_existent_user_specified_path(
-    tmpdir, browser, server
-):
+    tmp_path: Path, browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    [download, _] = await asyncio.gather(
-        page.wait_for_event("download"), page.click("a")
-    )
-    nested_path = tmpdir / "these" / "are" / "directories" / "download.txt"
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
+    nested_path = tmp_path / "these" / "are" / "directories" / "download.txt"
     await download.save_as(nested_path)
     assert nested_path.exists()
     assert nested_path.read_text("utf-8") == "Hello world"
@@ -161,40 +170,48 @@ async def test_should_create_subdirectories_when_saving_to_non_existent_user_spe
 
 
 async def test_should_error_when_saving_with_downloads_disabled(
-    tmpdir, browser, server
-):
+    tmp_path: Path, browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=False)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    [download, _] = await asyncio.gather(
-        page.wait_for_event("download"), page.click("a")
-    )
-    user_path = tmpdir / "download.txt"
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
+    user_path = tmp_path / "download.txt"
     with pytest.raises(Error) as exc:
         await download.save_as(user_path)
     assert (
-        "Pass { accept_downloads: True } when you are creating your browser context"
+        "Pass 'accept_downloads=True' when you are creating your browser context"
         in exc.value.message
     )
+    assert (
+        "Pass 'accept_downloads=True' when you are creating your browser context."
+        == await download.failure()
+    )
     await page.close()
 
 
-async def test_should_error_when_saving_after_deletion(tmpdir, browser, server):
+async def test_should_error_when_saving_after_deletion(
+    tmp_path: Path, browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    [download, _] = await asyncio.gather(
-        page.wait_for_event("download"), page.click("a")
-    )
-    user_path = tmpdir / "download.txt"
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
+    user_path = tmp_path / "download.txt"
     await download.delete()
     with pytest.raises(Error) as exc:
         await download.save_as(user_path)
-    assert "Download already deleted. Save before deleting." in exc.value.message
+    assert TARGET_CLOSED_ERROR_MESSAGE in exc.value.message
     await page.close()
 
 
-async def test_should_report_non_navigation_downloads(browser, server):
+async def test_should_report_non_navigation_downloads(
+    browser: Browser, server: Server
+) -> None:
     # Mac WebKit embedder does not download in this case, although Safari does.
-    def handle_download(request):
+    def handle_download(request: TestServerRequest) -> None:
         request.setHeader("Content-Type", "application/octet-stream")
         request.write(b"Hello world")
         request.finish()
@@ -206,9 +223,9 @@ def handle_download(request):
     await page.set_content(
         f'<a download="file.txt" href="{server.PREFIX}/download">download</a>'
     )
-    download = (await asyncio.gather(page.wait_for_event("download"), page.click("a")))[
-        0
-    ]
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
     assert download.suggested_filename == "file.txt"
     path = await download.path()
     assert os.path.exists(path)
@@ -217,12 +234,12 @@ def handle_download(request):
 
 
 async def test_report_download_path_within_page_on_download_handler_for_files(
-    browser: Browser, server
-):
+    browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=True)
-    on_download_path: Future[str] = asyncio.Future()
+    on_download_path: Future[Path] = asyncio.Future()
 
-    async def on_download(download):
+    async def on_download(download: Download) -> None:
         on_download_path.set_result(await download.path())
 
     page.once(
@@ -237,12 +254,12 @@ async def on_download(download):
 
 
 async def test_download_report_download_path_within_page_on_handle_for_blobs(
-    browser, server
-):
+    browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=True)
-    on_download_path = asyncio.Future()
+    on_download_path: "asyncio.Future[Path]" = asyncio.Future()
 
-    async def on_download(download):
+    async def on_download(download: Download) -> None:
         on_download_path.set_result(await download.path())
 
     page.once(
@@ -258,10 +275,12 @@ async def on_download(download):
 
 
 @pytest.mark.only_browser("chromium")
-async def test_should_report_alt_click_downloads(browser, server):
+async def test_should_report_alt_click_downloads(
+    browser: Browser, server: Server
+) -> None:
     # Firefox does not download on alt-click by default.
     # Our WebKit embedder does not download on alt-click, although Safari does.
-    def handle_download(request):
+    def handle_download(request: TestServerRequest) -> None:
         request.setHeader("Content-Type", "application/octet-stream")
         request.write(b"Hello world")
         request.finish()
@@ -271,39 +290,36 @@ def handle_download(request):
     page = await browser.new_page(accept_downloads=True)
     await page.goto(server.EMPTY_PAGE)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    download = (
-        await asyncio.gather(
-            page.wait_for_event("download"), page.click("a", modifiers=["Alt"])
-        )
-    )[0]
+    async with page.expect_download() as download_info:
+        await page.click("a", modifiers=["Alt"])
+    download = await download_info.value
     path = await download.path()
     assert os.path.exists(path)
     assert_file_content(path, "Hello world")
     await page.close()
 
 
-async def test_should_report_new_window_downloads(browser, server):
-    # TODO: - the test fails in headful Chromium as the popup page gets closed along
-    # with the session before download completed event arrives.
-    # - WebKit doesn't close the popup page
+async def test_should_report_new_window_downloads(
+    browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(
         f'<a target=_blank href="{server.PREFIX}/download">download</a>'
     )
-    download = (await asyncio.gather(page.wait_for_event("download"), page.click("a")))[
-        0
-    ]
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
     path = await download.path()
     assert os.path.exists(path)
     await page.close()
 
 
-async def test_should_delete_file(browser, server):
+async def test_should_delete_file(browser: Browser, server: Server) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    download = (await asyncio.gather(page.wait_for_event("download"), page.click("a")))[
-        0
-    ]
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
     path = await download.path()
     assert os.path.exists(path)
     await download.delete()
@@ -311,15 +327,17 @@ async def test_should_delete_file(browser, server):
     await page.close()
 
 
-async def test_should_delete_downloads_on_context_destruction(browser, server):
+async def test_should_delete_downloads_on_context_destruction(
+    browser: Browser, server: Server
+) -> None:
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    download1 = (
-        await asyncio.gather(page.wait_for_event("download"), page.click("a"))
-    )[0]
-    download2 = (
-        await asyncio.gather(page.wait_for_event("download"), page.click("a"))
-    )[0]
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download1 = await download_info.value
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download2 = await download_info.value
     path1 = await download1.path()
     path2 = await download2.path()
     assert os.path.exists(path1)
@@ -329,16 +347,18 @@ async def test_should_delete_downloads_on_context_destruction(browser, server):
     assert os.path.exists(path2) is False
 
 
-async def test_should_delete_downloads_on_browser_gone(browser_factory, server):
+async def test_should_delete_downloads_on_browser_gone(
+    browser_factory: "Callable[..., asyncio.Future[Browser]]", server: Server
+) -> None:
     browser = await browser_factory()
     page = await browser.new_page(accept_downloads=True)
     await page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
-    download1 = (
-        await asyncio.gather(page.wait_for_event("download"), page.click("a"))
-    )[0]
-    download2 = (
-        await asyncio.gather(page.wait_for_event("download"), page.click("a"))
-    )[0]
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download1 = await download_info.value
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download2 = await download_info.value
     path1 = await download1.path()
     path2 = await download2.path()
     assert os.path.exists(path1)
@@ -347,3 +367,22 @@ async def test_should_delete_downloads_on_browser_gone(browser_factory, server):
     assert os.path.exists(path1) is False
     assert os.path.exists(path2) is False
     assert os.path.exists(os.path.join(path1, "..")) is False
+
+
+async def test_download_cancel_should_work(browser: Browser, server: Server) -> None:
+    def handle_download(request: TestServerRequest) -> None:
+        request.setHeader("Content-Type", "application/octet-stream")
+        request.setHeader("Content-Disposition", "attachment")
+        # Chromium requires a large enough payload to trigger the download event soon enough
+        request.write(b"a" * 4096)
+        request.write(b"foo")
+
+    server.set_route("/downloadWithDelay", handle_download)
+    page = await browser.new_page(accept_downloads=True)
+    await page.set_content(f'<a href="{server.PREFIX}/downloadWithDelay">download</a>')
+    async with page.expect_download() as download_info:
+        await page.click("a")
+    download = await download_info.value
+    await download.cancel()
+    assert await download.failure() == "canceled"
+    await page.close()
diff --git a/tests/async/test_element_handle.py b/tests/async/test_element_handle.py
index 0ec388743..847b068be 100644
--- a/tests/async/test_element_handle.py
+++ b/tests/async/test_element_handle.py
@@ -13,50 +13,64 @@
 # limitations under the License.
 
 import asyncio
+from typing import Optional, cast
 
-from playwright.async_api import Error, FloatRect
+import pytest
 
+from playwright.async_api import Browser, ElementHandle, Error, FloatRect, Page
+from tests.server import Server
 
-async def test_bounding_box(page, server):
-    await page.set_viewport_size(500, 500)
+from .utils import Utils
+
+
+async def test_bounding_box(page: Page, server: Server) -> None:
+    await page.set_viewport_size({"width": 500, "height": 500})
     await page.goto(server.PREFIX + "/grid.html")
     element_handle = await page.query_selector(".box:nth-of-type(13)")
+    assert element_handle
     box = await element_handle.bounding_box()
-    assert box == FloatRect(100, 50, 50, 50)
+    assert box == {"x": 100, "y": 50, "width": 50, "height": 50}
 
 
-async def test_bounding_box_handle_nested_frames(page, server):
-    await page.set_viewport_size(500, 500)
+async def test_bounding_box_handle_nested_frames(page: Page, server: Server) -> None:
+    await page.set_viewport_size({"width": 500, "height": 500})
     await page.goto(server.PREFIX + "/frames/nested-frames.html")
     nested_frame = page.frame(name="dos")
+    assert nested_frame
     element_handle = await nested_frame.query_selector("div")
+    assert element_handle
     box = await element_handle.bounding_box()
-    assert box == FloatRect(24, 224, 268, 18)
+    assert box == {"x": 24, "y": 224, "width": 268, "height": 18}
 
 
-async def test_bounding_box_return_null_for_invisible_elements(page, server):
+async def test_bounding_box_return_null_for_invisible_elements(
+    page: Page, server: Server
+) -> None:
     await page.set_content('<div style="display:none">hi</div>')
     element = await page.query_selector("div")
+    assert element
     assert await element.bounding_box() is None
 
 
-async def test_bounding_box_force_a_layout(page, server):
-    await page.set_viewport_size(500, 500)
+async def test_bounding_box_force_a_layout(page: Page, server: Server) -> None:
+    await page.set_viewport_size({"width": 500, "height": 500})
     await page.set_content('<div style="width: 100px; height: 100px">hello</div>')
     element_handle = await page.query_selector("div")
+    assert element_handle
     await page.evaluate('element => element.style.height = "200px"', element_handle)
     box = await element_handle.bounding_box()
-    assert box == FloatRect(8, 8, 100, 200)
+    assert box == {"x": 8, "y": 8, "width": 100, "height": 200}
 
 
-async def test_bounding_box_with_SVG_nodes(page, server):
+async def test_bounding_box_with_SVG_nodes(page: Page, server: Server) -> None:
     await page.set_content(
         """<svg xmlns="http://www.w3.org/2000/svg" width="500" height="500">
              <rect id="theRect" x="30" y="50" width="200" height="300"></rect>
            </svg>"""
     )
     element = await page.query_selector("#therect")
-    pwBounding_box = await element.bounding_box()
+    assert element
+    pw_bounding_box = await element.bounding_box()
     web_bounding_box = await page.evaluate(
         """e => {
             rect = e.getBoundingClientRect()
@@ -64,16 +78,18 @@ async def test_bounding_box_with_SVG_nodes(page, server):
         }""",
         element,
     )
-    assert pwBounding_box == FloatRect._parse(web_bounding_box)
+    assert pw_bounding_box == web_bounding_box
 
 
-async def test_bounding_box_with_page_scale(browser, server):
+@pytest.mark.skip_browser("firefox")
+async def test_bounding_box_with_page_scale(browser: Browser, server: Server) -> None:
     context = await browser.new_context(
-        viewport={"width": 400, "height": 400, "is_mobile": True}
+        viewport={"width": 400, "height": 400}, is_mobile=True
     )
     page = await context.new_page()
     await page.goto(server.PREFIX + "/input/button.html")
     button = await page.query_selector("button")
+    assert button
     await button.evaluate(
         """button => {
             document.body.style.margin = '0'
@@ -86,14 +102,17 @@ async def test_bounding_box_with_page_scale(browser, server):
     )
 
     box = await button.bounding_box()
-    assert round(box.x * 100) == 17 * 100
-    assert round(box.y * 100) == 23 * 100
-    assert round(box.width * 100) == 200 * 100
-    assert round(box.height * 100) == 20 * 100
+    assert box
+    assert round(box["x"] * 100) == 17 * 100
+    assert round(box["y"] * 100) == 23 * 100
+    assert round(box["width"] * 100) == 200 * 100
+    assert round(box["height"] * 100) == 20 * 100
     await context.close()
 
 
-async def test_bounding_box_when_inline_box_child_is_outside_of_viewport(page, server):
+async def test_bounding_box_when_inline_box_child_is_outside_of_viewport(
+    page: Page,
+) -> None:
     await page.set_content(
         """
             <style>
@@ -110,104 +129,128 @@ async def test_bounding_box_when_inline_box_child_is_outside_of_viewport(page, s
         """
     )
     handle = await page.query_selector("span")
+    assert handle
     box = await handle.bounding_box()
-    web_bounding_box = FloatRect._parse(
-        await handle.evaluate(
-            """e => {
-            rect = e.getBoundingClientRect();
-            return {x: rect.x, y: rect.y, width: rect.width, height: rect.height};
-        }"""
-        )
+    web_bounding_box = await handle.evaluate(
+        """e => {
+        rect = e.getBoundingClientRect();
+        return {x: rect.x, y: rect.y, width: rect.width, height: rect.height};
+    }"""
     )
 
-    def roundbox(b):
+    def roundbox(b: Optional[FloatRect]) -> FloatRect:
+        assert b
         return {
-            "x": round(b.x * 100),
-            "y": round(b.y * 100),
-            "width": round(b.width * 100),
-            "height": round(b.height * 100),
+            "x": round(b["x"] * 100),
+            "y": round(b["y"] * 100),
+            "width": round(b["width"] * 100),
+            "height": round(b["height"] * 100),
         }
 
     assert roundbox(box) == roundbox(web_bounding_box)
 
 
-async def test_content_frame(page, server, utils):
+async def test_content_frame(page: Page, server: Server, utils: Utils) -> None:
     await page.goto(server.EMPTY_PAGE)
     await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     element_handle = await page.query_selector("#frame1")
+    assert element_handle
     frame = await element_handle.content_frame()
     assert frame == page.frames[1]
 
 
-async def test_content_frame_for_non_iframes(page, server, utils):
+async def test_content_frame_for_non_iframes(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     frame = page.frames[1]
-    element_handle = await frame.evaluate_handle("document.body")
+    element_handle = cast(ElementHandle, await frame.evaluate_handle("document.body"))
     assert await element_handle.content_frame() is None
 
 
-async def test_content_frame_for_document_element(page, server, utils):
+async def test_content_frame_for_document_element(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     frame = page.frames[1]
-    element_handle = await frame.evaluate_handle("document.documentElement")
+    element_handle = cast(
+        ElementHandle, await frame.evaluate_handle("document.documentElement")
+    )
     assert await element_handle.content_frame() is None
 
 
-async def test_owner_frame(page, server, utils):
+async def test_owner_frame(page: Page, server: Server, utils: Utils) -> None:
     await page.goto(server.EMPTY_PAGE)
     await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     frame = page.frames[1]
-    element_handle = await frame.evaluate_handle("document.body")
+    element_handle = cast(ElementHandle, await frame.evaluate_handle("document.body"))
     assert await element_handle.owner_frame() == frame
 
 
-async def test_owner_frame_for_cross_process_iframes(page, server, utils):
+async def test_owner_frame_for_cross_process_iframes(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await utils.attach_frame(
         page, "frame1", server.CROSS_PROCESS_PREFIX + "/empty.html"
     )
     frame = page.frames[1]
-    element_handle = await frame.evaluate_handle("document.body")
+    element_handle = cast(ElementHandle, await frame.evaluate_handle("document.body"))
     assert await element_handle.owner_frame() == frame
 
 
-async def test_owner_frame_for_document(page, server, utils):
+async def test_owner_frame_for_document(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     frame = page.frames[1]
-    element_handle = await frame.evaluate_handle("document")
+    element_handle = cast(ElementHandle, await frame.evaluate_handle("document"))
     assert await element_handle.owner_frame() == frame
 
 
-async def test_owner_frame_for_iframe_elements(page, server, utils):
+async def test_owner_frame_for_iframe_elements(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     frame = page.main_frame
-    element_handle = await frame.evaluate_handle('document.querySelector("#frame1")')
+    element_handle = cast(
+        ElementHandle, await frame.evaluate_handle('document.querySelector("#frame1")')
+    )
     assert await element_handle.owner_frame() == frame
 
 
-async def test_owner_frame_for_cross_frame_evaluations(page, server, utils):
+async def test_owner_frame_for_cross_frame_evaluations(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     frame = page.main_frame
-    element_handle = await frame.evaluate_handle(
-        'document.querySelector("#frame1").contentWindow.document.body'
+    element_handle = cast(
+        ElementHandle,
+        await frame.evaluate_handle(
+            'document.querySelector("#frame1").contentWindow.document.body'
+        ),
     )
     assert await element_handle.owner_frame() == frame.child_frames[0]
 
 
-async def test_owner_frame_for_detached_elements(page, server):
+async def test_owner_frame_for_detached_elements(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
-    div_handle = await page.evaluate_handle(
-        """() => {
+    div_handle = cast(
+        ElementHandle,
+        await page.evaluate_handle(
+            """() => {
             div = document.createElement('div');
             document.body.appendChild(div);
             return div;
         }"""
+        ),
     )
+    assert div_handle
 
     assert await div_handle.owner_frame() == page.main_frame
     await page.evaluate(
@@ -219,19 +262,24 @@ async def test_owner_frame_for_detached_elements(page, server):
     assert await div_handle.owner_frame() == page.main_frame
 
 
-async def test_owner_frame_for_adopted_elements(page, server):
+async def test_owner_frame_for_adopted_elements(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
-    [popup, _] = await asyncio.gather(
-        page.wait_for_event("popup"),
-        page.evaluate("url => window.__popup = window.open(url)", server.EMPTY_PAGE),
-    )
-    div_handle = await page.evaluate_handle(
-        """() => {
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
+            "url => window.__popup = window.open(url)", server.EMPTY_PAGE
+        )
+    popup = await popup_info.value
+    div_handle = cast(
+        ElementHandle,
+        await page.evaluate_handle(
+            """() => {
             div = document.createElement('div');
             document.body.appendChild(div);
             return div;
         }"""
+        ),
     )
+    assert div_handle
     assert await div_handle.owner_frame() == page.main_frame
     await popup.wait_for_load_state("domcontentloaded")
     await page.evaluate(
@@ -243,82 +291,86 @@ async def test_owner_frame_for_adopted_elements(page, server):
     assert await div_handle.owner_frame() == popup.main_frame
 
 
-async def test_click(page, server):
+async def test_click(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     button = await page.query_selector("button")
+    assert button
     await button.click()
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_click_with_node_removed(page, server):
+async def test_click_with_node_removed(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.evaluate('delete window["Node"]')
     button = await page.query_selector("button")
+    assert button
     await button.click()
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_click_for_shadow_dom_v1(page, server):
+async def test_click_for_shadow_dom_v1(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/shadow.html")
-    button_handle = await page.evaluate_handle("button")
+    button_handle = cast(ElementHandle, await page.evaluate_handle("button"))
     await button_handle.click()
     assert await page.evaluate("clicked")
 
 
-async def test_click_for_TextNodes(page, server):
+async def test_click_for_TextNodes(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
-    buttonTextNode = await page.evaluate_handle(
-        'document.querySelector("button").firstChild'
+    buttonTextNode = cast(
+        ElementHandle,
+        await page.evaluate_handle('document.querySelector("button").firstChild'),
     )
     await buttonTextNode.click()
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_click_throw_for_detached_nodes(page, server):
+async def test_click_throw_for_detached_nodes(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     button = await page.query_selector("button")
+    assert button
     await page.evaluate("button => button.remove()", button)
-    error = None
-    try:
+    with pytest.raises(Error) as exc_info:
         await button.click()
-    except Error as e:
-        error = e
-    assert "Element is not attached to the DOM" in error.message
+    assert "Element is not attached to the DOM" in exc_info.value.message
 
 
-async def test_click_throw_for_hidden_nodes_with_force(page, server):
+async def test_click_throw_for_hidden_nodes_with_force(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     button = await page.query_selector("button")
+    assert button
     await page.evaluate('button => button.style.display = "none"', button)
-    try:
+    with pytest.raises(Error) as exc_info:
         await button.click(force=True)
-    except Error as e:
-        error = e
-    assert "Element is not visible" in error.message
+    assert "Element is not visible" in exc_info.value.message
 
 
-async def test_click_throw_for_recursively_hidden_nodes_with_force(page, server):
+async def test_click_throw_for_recursively_hidden_nodes_with_force(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     button = await page.query_selector("button")
+    assert button
     await page.evaluate('button => button.parentElement.style.display = "none"', button)
-    try:
+    with pytest.raises(Error) as exc_info:
         await button.click(force=True)
-    except Error as e:
-        error = e
-    assert "Element is not visible" in error.message
+    assert "Element is not visible" in exc_info.value.message
 
 
-async def test_click_throw_for__br__elements_with_force(page, server):
+async def test_click_throw_for__br__elements_with_force(
+    page: Page, server: Server
+) -> None:
     await page.set_content("hello<br>goodbye")
     br = await page.query_selector("br")
-    try:
+    assert br
+    with pytest.raises(Error) as exc_info:
         await br.click(force=True)
-    except Error as e:
-        error = e
-    assert "Element is outside of the viewport" in error.message
+    assert "Element is outside of the viewport" in exc_info.value.message
 
 
-async def test_double_click_the_button(page, server):
+async def test_double_click_the_button(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     await page.evaluate(
         """() => {
@@ -330,34 +382,38 @@ async def test_double_click_the_button(page, server):
         }"""
     )
     button = await page.query_selector("button")
+    assert button
     await button.dblclick()
     assert await page.evaluate("double")
     assert await page.evaluate("result") == "Clicked"
 
 
-async def test_hover(page, server):
+async def test_hover(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/scrollable.html")
     button = await page.query_selector("#button-6")
+    assert button
     await button.hover()
     assert (
         await page.evaluate('document.querySelector("button:hover").id') == "button-6"
     )
 
 
-async def test_hover_when_node_is_removed(page, server):
+async def test_hover_when_node_is_removed(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/scrollable.html")
     await page.evaluate('delete window["Node"]')
     button = await page.query_selector("#button-6")
+    assert button
     await button.hover()
     assert (
         await page.evaluate('document.querySelector("button:hover").id') == "button-6"
     )
 
 
-async def test_scroll(page, server):
+async def test_scroll(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/offscreenbuttons.html")
     for i in range(11):
         button = await page.query_selector(f"#btn{i}")
+        assert button
         before = await button.evaluate(
             """button => {
                 return button.getBoundingClientRect().right - window.innerWidth
@@ -376,22 +432,24 @@ async def test_scroll(page, server):
         await page.evaluate("() => window.scrollTo(0, 0)")
 
 
-async def test_scroll_should_throw_for_detached_element(page, server):
+async def test_scroll_should_throw_for_detached_element(
+    page: Page, server: Server
+) -> None:
     await page.set_content("<div>Hello</div>")
     div = await page.query_selector("div")
+    assert div
     await div.evaluate("div => div.remove()")
-    try:
+    with pytest.raises(Error) as exc_info:
         await div.scroll_into_view_if_needed()
-    except Error as e:
-        error = e
-    assert "Element is not attached to the DOM" in error.message
+    assert "Element is not attached to the DOM" in exc_info.value.message
 
 
-async def waiting_helper(page, after):
+async def waiting_helper(page: Page, after: str) -> None:
     div = await page.query_selector("div")
-    done = list()
+    assert div
+    done = []
 
-    async def scroll():
+    async def scroll() -> None:
         done.append(False)
         await div.scroll_into_view_if_needed()
         done.append(True)
@@ -405,62 +463,68 @@ async def scroll():
     assert done == [False, True]
 
 
-async def test_should_wait_for_display_none_to_become_visible(page):
+async def test_should_wait_for_display_none_to_become_visible(page: Page) -> None:
     await page.set_content('<div style="display:none">Hello</div>')
     await waiting_helper(page, 'div => div.style.display = "block"')
 
 
-async def test_should_wait_for_display_contents_to_become_visible(page):
-    await page.set_content('<div style="display:contents">Hello</div>')
-    await waiting_helper(page, 'div => div.style.display = "block"')
-
-
-async def test_should_wait_for_visibility_hidden_to_become_visible(page):
+async def test_should_work_for_visibility_hidden_element(page: Page) -> None:
     await page.set_content('<div style="visibility:hidden">Hello</div>')
-    await waiting_helper(page, 'div => div.style.visibility = "visible"')
+    div = await page.query_selector("div")
+    assert div
+    await div.scroll_into_view_if_needed()
 
 
-async def test_should_wait_for_zero_sized_element_to_become_visible(page):
+async def test_should_work_for_zero_sized_element(page: Page) -> None:
     await page.set_content('<div style="height:0">Hello</div>')
-    await waiting_helper(page, 'div => div.style.height = "100px"')
+    div = await page.query_selector("div")
+    assert div
+    await div.scroll_into_view_if_needed()
 
 
-async def test_should_wait_for_nested_display_none_to_become_visible(page):
+async def test_should_wait_for_nested_display_none_to_become_visible(
+    page: Page,
+) -> None:
     await page.set_content('<span style="display:none"><div>Hello</div></span>')
     await waiting_helper(page, 'div => div.parentElement.style.display = "block"')
 
 
-async def test_should_timeout_waiting_for_visible(page):
+async def test_should_timeout_waiting_for_visible(page: Page) -> None:
     await page.set_content('<div style="display:none">Hello</div>')
     div = await page.query_selector("div")
-    try:
-        error = await div.scroll_into_view_if_needed(timeout=3000)
-    except Error as e:
-        error = e
-    assert "element is not visible" in error.message
+    assert div
+    with pytest.raises(Error) as exc_info:
+        await div.scroll_into_view_if_needed(timeout=3000)
+    assert "element is not visible" in exc_info.value.message
+    assert "retrying scroll into view action" in exc_info.value.message
 
 
-async def test_fill_input(page, server):
+async def test_fill_input(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     handle = await page.query_selector("input")
+    assert handle
     await handle.fill("some value")
     assert await page.evaluate("result") == "some value"
 
 
-async def test_fill_input_when_Node_is_removed(page, server):
+async def test_fill_input_when_Node_is_removed(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.evaluate('delete window["Node"]')
     handle = await page.query_selector("input")
+    assert handle
     await handle.fill("some value")
     assert await page.evaluate("result") == "some value"
 
 
-async def test_select_textarea(page, server, is_firefox):
+async def test_select_textarea(
+    page: Page, server: Server, is_firefox: bool, is_webkit: bool
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     textarea = await page.query_selector("textarea")
+    assert textarea
     await textarea.evaluate('textarea => textarea.value = "some value"')
     await textarea.select_text()
-    if is_firefox:
+    if is_firefox or is_webkit:
         assert await textarea.evaluate("el => el.selectionStart") == 0
         assert await textarea.evaluate("el => el.selectionEnd") == 10
     else:
@@ -470,12 +534,15 @@ async def test_select_textarea(page, server, is_firefox):
         )
 
 
-async def test_select_input(page, server, is_firefox):
+async def test_select_input(
+    page: Page, server: Server, is_firefox: bool, is_webkit: bool
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     input = await page.query_selector("input")
+    assert input
     await input.evaluate('input => input.value = "some value"')
     await input.select_text()
-    if is_firefox:
+    if is_firefox or is_webkit:
         assert await input.evaluate("el => el.selectionStart") == 0
         assert await input.evaluate("el => el.selectionEnd") == 10
     else:
@@ -485,32 +552,35 @@ async def test_select_input(page, server, is_firefox):
         )
 
 
-async def test_select_text_select_plain_div(page, server):
+async def test_select_text_select_plain_div(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     div = await page.query_selector("div.plain")
+    assert div
     await div.select_text()
     assert await page.evaluate("() => window.getSelection().toString()") == "Plain div"
 
 
-async def test_select_text_timeout_waiting_for_invisible_element(page, server):
+async def test_select_text_timeout_waiting_for_invisible_element(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     textarea = await page.query_selector("textarea")
+    assert textarea
     await textarea.evaluate('e => e.style.display = "none"')
-    try:
+    with pytest.raises(Error) as exc_info:
         await textarea.select_text(timeout=3000)
-    except Error as e:
-        error = e
-    assert "element is not visible" in error.message
+    assert "element is not visible" in exc_info.value.message
 
 
-async def test_select_text_wait_for_visible(page, server):
+async def test_select_text_wait_for_visible(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     textarea = await page.query_selector("textarea")
+    assert textarea
     await textarea.evaluate('textarea => textarea.value = "some value"')
     await textarea.evaluate('e => e.style.display = "none"')
-    done = list()
+    done = []
 
-    async def select_text():
+    async def select_text() -> None:
         done.append(False)
         await textarea.select_text(timeout=3000)
         done.append(True)
@@ -523,10 +593,11 @@ async def select_text():
     assert done == [False, True]
 
 
-async def test_a_nice_preview(page, server):
+async def test_a_nice_preview(page: Page, server: Server) -> None:
     await page.goto(f"{server.PREFIX}/dom.html")
     outer = await page.query_selector("#outer")
     inner = await page.query_selector("#inner")
+    assert inner
     check = await page.query_selector("#check")
     text = await inner.evaluate_handle("e => e.firstChild")
     await page.evaluate("1")  # Give them a chance to calculate the preview.
@@ -538,76 +609,186 @@ async def test_a_nice_preview(page, server):
     )
 
 
-async def test_get_attribute(page, server):
+async def test_get_attribute(page: Page, server: Server) -> None:
     await page.goto(f"{server.PREFIX}/dom.html")
     handle = await page.query_selector("#outer")
+    assert handle
     assert await handle.get_attribute("name") == "value"
     assert await page.get_attribute("#outer", "name") == "value"
 
 
-async def test_inner_html(page, server):
+async def test_inner_html(page: Page, server: Server) -> None:
     await page.goto(f"{server.PREFIX}/dom.html")
     handle = await page.query_selector("#outer")
+    assert handle
     assert await handle.inner_html() == '<div id="inner">Text,\nmore text</div>'
     assert await page.inner_html("#outer") == '<div id="inner">Text,\nmore text</div>'
 
 
-async def test_inner_text(page, server):
+async def test_inner_text(page: Page, server: Server) -> None:
     await page.goto(f"{server.PREFIX}/dom.html")
     handle = await page.query_selector("#inner")
+    assert handle
     assert await handle.inner_text() == "Text, more text"
     assert await page.inner_text("#inner") == "Text, more text"
 
 
-async def test_inner_text_should_throw(page, server):
+async def test_inner_text_should_throw(page: Page, server: Server) -> None:
     await page.set_content("<svg>text</svg>")
-    error1 = None
-    try:
+    with pytest.raises(Error) as exc_info1:
         await page.inner_text("svg")
-    except Error as e:
-        error1 = e
-    assert "Not an HTMLElement" in error1.message
+    assert " Node is not an HTMLElement" in exc_info1.value.message
+
     handle = await page.query_selector("svg")
-    error2 = None
-    try:
+    assert handle
+    with pytest.raises(Error) as exc_info2:
         await handle.inner_text()
-    except Error as e:
-        error2 = e
-    assert "Not an HTMLElement" in error2.message
+    assert " Node is not an HTMLElement" in exc_info2.value.message
 
 
-async def test_text_content(page, server):
+async def test_text_content(page: Page, server: Server) -> None:
     await page.goto(f"{server.PREFIX}/dom.html")
     handle = await page.query_selector("#inner")
+    assert handle
     assert await handle.text_content() == "Text,\nmore text"
     assert await page.text_content("#inner") == "Text,\nmore text"
 
 
-async def test_check_the_box(page):
+async def test_check_the_box(page: Page) -> None:
     await page.set_content('<input id="checkbox" type="checkbox"></input>')
     input = await page.query_selector("input")
+    assert input
     await input.check()
     assert await page.evaluate("checkbox.checked")
 
 
-async def test_uncheck_the_box(page):
+async def test_uncheck_the_box(page: Page) -> None:
     await page.set_content('<input id="checkbox" type="checkbox" checked></input>')
     input = await page.query_selector("input")
+    assert input
     await input.uncheck()
     assert await page.evaluate("checkbox.checked") is False
 
 
-async def test_select_single_option(page, server):
+async def test_select_single_option(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/select.html")
     select = await page.query_selector("select")
+    assert select
     await select.select_option(value="blue")
     assert await page.evaluate("result.onInput") == ["blue"]
     assert await page.evaluate("result.onChange") == ["blue"]
 
 
-async def test_focus_a_button(page, server):
+async def test_focus_a_button(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/button.html")
     button = await page.query_selector("button")
+    assert button
     assert await button.evaluate("button => document.activeElement === button") is False
     await button.focus()
     assert await button.evaluate("button => document.activeElement === button")
+
+
+async def test_is_visible_and_is_hidden_should_work(page: Page) -> None:
+    await page.set_content("<div>Hi</div><span></span>")
+    div = await page.query_selector("div")
+    assert div
+    assert await div.is_visible()
+    assert await div.is_hidden() is False
+    assert await page.is_visible("div")
+    assert await page.is_hidden("div") is False
+    span = await page.query_selector("span")
+    assert span
+    assert await span.is_visible() is False
+    assert await span.is_hidden()
+    assert await page.is_visible("span") is False
+    assert await page.is_hidden("span")
+
+
+async def test_is_enabled_and_is_disabled_should_work(page: Page) -> None:
+    await page.set_content(
+        """
+        <button disabled>button1</button>
+        <button>button2</button>
+        <div>div</div>
+    """
+    )
+    div = await page.query_selector("div")
+    assert div
+    assert await div.is_enabled()
+    assert await div.is_disabled() is False
+    assert await page.is_enabled("div")
+    assert await page.is_disabled("div") is False
+    button1 = await page.query_selector(":text('button1')")
+    assert button1
+    assert await button1.is_enabled() is False
+    assert await button1.is_disabled()
+    assert await page.is_enabled(":text('button1')") is False
+    assert await page.is_disabled(":text('button1')")
+    button2 = await page.query_selector(":text('button2')")
+    assert button2
+    assert await button2.is_enabled()
+    assert await button2.is_disabled() is False
+    assert await page.is_enabled(":text('button2')")
+    assert await page.is_disabled(":text('button2')") is False
+
+
+async def test_is_editable_should_work(page: Page) -> None:
+    await page.set_content(
+        "<input id=input1 disabled><textarea></textarea><input id=input2>"
+    )
+    await page.eval_on_selector("textarea", "t => t.readOnly = true")
+    input1 = await page.query_selector("#input1")
+    assert input1
+    assert await input1.is_editable() is False
+    assert await page.is_editable("#input1") is False
+    input2 = await page.query_selector("#input2")
+    assert input2
+    assert await input2.is_editable()
+    assert await page.is_editable("#input2")
+    textarea = await page.query_selector("textarea")
+    assert textarea
+    assert await textarea.is_editable() is False
+    assert await page.is_editable("textarea") is False
+
+
+async def test_is_checked_should_work(page: Page) -> None:
+    await page.set_content('<input type="checkbox" checked><div>Not a checkbox</div>')
+    handle = await page.query_selector("input")
+    assert handle
+    assert await handle.is_checked()
+    assert await page.is_checked("input")
+    await handle.evaluate("input => input.checked = false")
+    assert await handle.is_checked() is False
+    assert await page.is_checked("input") is False
+    with pytest.raises(Error) as exc_info:
+        await page.is_checked("div")
+    assert "Not a checkbox or radio button" in exc_info.value.message
+
+
+async def test_input_value(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/textarea.html")
+    element = await page.query_selector("input")
+    assert element
+    await element.fill("my-text-content")
+    assert await element.input_value() == "my-text-content"
+
+    await element.fill("")
+    assert await element.input_value() == ""
+
+
+async def test_set_checked(page: Page) -> None:
+    await page.set_content("`<input id='checkbox' type='checkbox'></input>`")
+    input = await page.query_selector("input")
+    assert input
+    await input.set_checked(True)
+    assert await page.evaluate("checkbox.checked")
+    await input.set_checked(False)
+    assert await page.evaluate("checkbox.checked") is False
+
+
+async def test_should_allow_disposing_twice(page: Page) -> None:
+    await page.set_content("<section>39</section>")
+    element = await page.query_selector("section")
+    assert element
+    await element.dispose()
+    await element.dispose()
diff --git a/tests/async/test_element_handle_wait_for_element_state.py b/tests/async/test_element_handle_wait_for_element_state.py
new file mode 100644
index 000000000..80019de45
--- /dev/null
+++ b/tests/async/test_element_handle_wait_for_element_state.py
@@ -0,0 +1,158 @@
+# 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 asyncio
+from typing import List
+
+import pytest
+
+from playwright.async_api import ElementHandle, Error, Page
+from tests.server import Server
+
+
+async def give_it_a_chance_to_resolve(page: Page) -> None:
+    for i in range(5):
+        await page.evaluate(
+            "() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f)))"
+        )
+
+
+async def wait_for_state(div: ElementHandle, state: str, done: List[bool]) -> None:
+    await div.wait_for_element_state(state)  # type: ignore
+    done[0] = True
+
+
+async def wait_for_state_to_throw(
+    div: ElementHandle, state: str
+) -> pytest.ExceptionInfo[Error]:
+    with pytest.raises(Error) as exc_info:
+        await div.wait_for_element_state(state)  # type: ignore
+    return exc_info
+
+
+async def test_should_wait_for_visible(page: Page) -> None:
+    await page.set_content('<div style="display:none">content</div>')
+    div = await page.query_selector("div")
+    assert div
+    done = [False]
+    promise = asyncio.create_task(wait_for_state(div, "visible", done))
+    await give_it_a_chance_to_resolve(page)
+    assert done[0] is False
+    assert div
+    await div.evaluate('div => div.style.display = "block"')
+    await promise
+
+
+async def test_should_wait_for_already_visible(page: Page) -> None:
+    await page.set_content("<div>content</div>")
+    div = await page.query_selector("div")
+    assert div
+    await div.wait_for_element_state("visible")
+
+
+async def test_should_timeout_waiting_for_visible(page: Page) -> None:
+    await page.set_content('<div style="display:none">content</div>')
+    div = await page.query_selector("div")
+    assert div
+    with pytest.raises(Error) as exc_info:
+        await div.wait_for_element_state("visible", timeout=1000)
+    assert "Timeout 1000ms exceeded" in exc_info.value.message
+
+
+async def test_should_throw_waiting_for_visible_when_detached(page: Page) -> None:
+    await page.set_content('<div style="display:none">content</div>')
+    div = await page.query_selector("div")
+    assert div
+    promise = asyncio.create_task(wait_for_state_to_throw(div, "visible"))
+    await div.evaluate("div => div.remove()")
+    exc_info = await promise
+    assert "Element is not attached to the DOM" in exc_info.value.message
+
+
+async def test_should_wait_for_hidden(page: Page) -> None:
+    await page.set_content("<div>content</div>")
+    div = await page.query_selector("div")
+    assert div
+    done = [False]
+    promise = asyncio.create_task(wait_for_state(div, "hidden", done))
+    await give_it_a_chance_to_resolve(page)
+    assert done[0] is False
+    await div.evaluate('div => div.style.display = "none"')
+    await promise
+
+
+async def test_should_wait_for_already_hidden(page: Page) -> None:
+    await page.set_content("<div></div>")
+    div = await page.query_selector("div")
+    assert div
+    await div.wait_for_element_state("hidden")
+
+
+async def test_should_wait_for_hidden_when_detached(page: Page) -> None:
+    await page.set_content("<div>content</div>")
+    div = await page.query_selector("div")
+    assert div
+    done = [False]
+    promise = asyncio.create_task(wait_for_state(div, "hidden", done))
+    await give_it_a_chance_to_resolve(page)
+    assert done[0] is False
+    assert div
+    await div.evaluate("div => div.remove()")
+    await promise
+
+
+async def test_should_wait_for_enabled_button(page: Page, server: Server) -> None:
+    await page.set_content("<button disabled><span>Target</span></button>")
+    span = await page.query_selector("text=Target")
+    assert span
+    done = [False]
+    promise = asyncio.create_task(wait_for_state(span, "enabled", done))
+    await give_it_a_chance_to_resolve(page)
+    assert done[0] is False
+    await span.evaluate("span => span.parentElement.disabled = false")
+    await promise
+
+
+async def test_should_throw_waiting_for_enabled_when_detached(page: Page) -> None:
+    await page.set_content("<button disabled>Target</button>")
+    button = await page.query_selector("button")
+    assert button
+    promise = asyncio.create_task(wait_for_state_to_throw(button, "enabled"))
+    await button.evaluate("button => button.remove()")
+    exc_info = await promise
+    assert "Element is not attached to the DOM" in exc_info.value.message
+
+
+async def test_should_wait_for_disabled_button(page: Page) -> None:
+    await page.set_content("<button><span>Target</span></button>")
+    span = await page.query_selector("text=Target")
+    assert span
+    done = [False]
+    promise = asyncio.create_task(wait_for_state(span, "disabled", done))
+    await give_it_a_chance_to_resolve(page)
+    assert done[0] is False
+    await span.evaluate("span => span.parentElement.disabled = true")
+    await promise
+
+
+async def test_should_wait_for_editable_input(page: Page, server: Server) -> None:
+    await page.set_content("<input readonly>")
+    input = await page.query_selector("input")
+    assert input
+    done = [False]
+    promise = asyncio.create_task(wait_for_state(input, "editable", done))
+    await give_it_a_chance_to_resolve(page)
+    assert done[0] is False
+    await input.evaluate("input => input.readOnly = false")
+    await promise
diff --git a/tests/async/test_emulation_focus.py b/tests/async/test_emulation_focus.py
index aa918b433..8f298f9ca 100644
--- a/tests/async/test_emulation_focus.py
+++ b/tests/async/test_emulation_focus.py
@@ -13,29 +13,35 @@
 # limitations under the License.
 import asyncio
 
+from playwright.async_api import Page
+from tests.server import Server
 
-async def test_should_think_that_it_is_focused_by_default(page):
+from .utils import Utils
+
+
+async def test_should_think_that_it_is_focused_by_default(page: Page) -> None:
     assert await page.evaluate("document.hasFocus()")
 
 
-async def test_should_think_that_all_pages_are_focused(page):
+async def test_should_think_that_all_pages_are_focused(page: Page) -> None:
     page2 = await page.context.new_page()
     assert await page.evaluate("document.hasFocus()")
     assert await page2.evaluate("document.hasFocus()")
     await page2.close()
 
 
-async def test_should_focus_popups_by_default(page, server):
+async def test_should_focus_popups_by_default(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
-    [popup, _] = await asyncio.gather(
-        page.wait_for_event("popup"),
-        page.evaluate("url => { window.open(url); }", server.EMPTY_PAGE),
-    )
+    async with page.expect_popup() as popup_info:
+        await page.evaluate("url => { window.open(url); }", server.EMPTY_PAGE)
+    popup = await popup_info.value
     assert await popup.evaluate("document.hasFocus()")
     assert await page.evaluate("document.hasFocus()")
 
 
-async def test_should_provide_target_for_keyboard_events(page, server):
+async def test_should_provide_target_for_keyboard_events(
+    page: Page, server: Server
+) -> None:
     page2 = await page.context.new_page()
     await asyncio.gather(
         page.goto(server.PREFIX + "/input/textarea.html"),
@@ -58,11 +64,13 @@ async def test_should_provide_target_for_keyboard_events(page, server):
     assert results == [text, text2]
 
 
-async def test_should_not_affect_mouse_event_target_page(page, server):
+async def test_should_not_affect_mouse_event_target_page(
+    page: Page, server: Server
+) -> None:
     page2 = await page.context.new_page()
-    click_counter = """() {
-    document.onclick = () => window.click_count  = (window.click_count || 0) + 1;
-  }"""
+    click_counter = """() => {
+      document.onclick = () => window.click_count = (window.click_count || 0) + 1;
+    }"""
     await asyncio.gather(
         page.evaluate(click_counter),
         page2.evaluate(click_counter),
@@ -80,7 +88,7 @@ async def test_should_not_affect_mouse_event_target_page(page, server):
     assert counters == [1, 1]
 
 
-async def test_should_change_document_activeElement(page, server):
+async def test_should_change_document_activeElement(page: Page, server: Server) -> None:
     page2 = await page.context.new_page()
     await asyncio.gather(
         page.goto(server.PREFIX + "/input/textarea.html"),
@@ -97,28 +105,9 @@ async def test_should_change_document_activeElement(page, server):
     assert active == ["INPUT", "TEXTAREA"]
 
 
-async def test_should_not_affect_screenshots(page, server, assert_to_be_golden):
-    # Firefox headful produces a different image.
-    page2 = await page.context.new_page()
-    await asyncio.gather(
-        page.set_viewport_size(width=500, height=500),
-        page.goto(server.PREFIX + "/grid.html"),
-        page2.set_viewport_size(width=50, height=50),
-        page2.goto(server.PREFIX + "/grid.html"),
-    )
-    await asyncio.gather(
-        page.focus("body"),
-        page2.focus("body"),
-    )
-    screenshots = await asyncio.gather(
-        page.screenshot(),
-        page2.screenshot(),
-    )
-    assert_to_be_golden(screenshots[0], "screenshot-sanity.png")
-    assert_to_be_golden(screenshots[1], "grid-cell-0.png")
-
-
-async def test_should_change_focused_iframe(page, server, utils):
+async def test_should_change_focused_iframe(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     [frame1, frame2] = await asyncio.gather(
         utils.attach_frame(page, "frame1", server.PREFIX + "/input/textarea.html"),
diff --git a/tests/async/test_evaluate.py b/tests/async/test_evaluate.py
deleted file mode 100644
index 3505a75fc..000000000
--- a/tests/async/test_evaluate.py
+++ /dev/null
@@ -1,215 +0,0 @@
-# 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 math
-from datetime import datetime
-
-from playwright.async_api import Error
-
-
-async def test_evaluate_work(page):
-    result = await page.evaluate("7 * 3")
-    assert result == 21
-
-
-async def test_evaluate_return_none_for_null(page):
-    result = await page.evaluate("a => a", None)
-    assert result is None
-
-
-async def test_evaluate_transfer_nan(page):
-    result = await page.evaluate("a => a", float("nan"))
-    assert math.isnan(result)
-
-
-async def test_evaluate_transfer_neg_zero(page):
-    result = await page.evaluate("a => a", -0)
-    assert result == float("-0")
-
-
-async def test_evaluate_transfer_infinity(page):
-    result = await page.evaluate("a => a", float("Infinity"))
-    assert result == float("Infinity")
-
-
-async def test_evaluate_transfer_neg_infinity(page):
-    result = await page.evaluate("a => a", float("-Infinity"))
-    assert result == float("-Infinity")
-
-
-async def test_evaluate_roundtrip_unserializable_values(page):
-    value = {
-        "infinity": float("Infinity"),
-        "nInfinity": float("-Infinity"),
-        "nZero": float("-0"),
-    }
-    result = await page.evaluate("a => a", value)
-    assert result == value
-
-
-async def test_evaluate_transfer_arrays(page):
-    result = await page.evaluate("a => a", [1, 2, 3])
-    assert result == [1, 2, 3]
-
-
-async def test_evaluate_return_undefined_for_objects_with_symbols(page):
-    assert await page.evaluate('[Symbol("foo4")]') == [None]
-    assert (
-        await page.evaluate(
-            """() => {
-                const a = { };
-                a[Symbol('foo4')] = 42;
-                return a;
-            }"""
-        )
-        == {}
-    )
-    assert (
-        await page.evaluate(
-            """() => {
-                return { foo: [{ a: Symbol('foo4') }] };
-            }"""
-        )
-        == {"foo": [{"a": None}]}
-    )
-
-
-async def test_evaluate_work_with_unicode_chars(page):
-    result = await page.evaluate('a => a["中文字符"]', {"中文字符": 42})
-    assert result == 42
-
-
-async def test_evaluate_throw_when_evaluation_triggers_reload(page):
-    error = None
-    try:
-        await page.evaluate(
-            "() => { location.reload(); return new Promise(() => {}); }"
-        )
-    except Error as e:
-        error = e
-    assert "navigation" in error.message
-
-
-async def test_evaluate_work_with_exposed_function(page):
-    await page.expose_function("callController", lambda a, b: a * b)
-    result = await page.evaluate("callController(9, 3)")
-    assert result == 27
-
-
-async def test_evaluate_reject_promise_with_exception(page):
-    error = None
-    try:
-        await page.evaluate("not_existing_object.property")
-    except Error as e:
-        error = e
-    assert "not_existing_object" in error.message
-
-
-async def test_evaluate_support_thrown_strings(page):
-    error = None
-    try:
-        await page.evaluate('throw "qwerty"')
-    except Error as e:
-        error = e
-    assert "qwerty" in error.message
-
-
-async def test_evaluate_support_thrown_numbers(page):
-    error = None
-    try:
-        await page.evaluate("throw 100500")
-    except Error as e:
-        error = e
-    assert "100500" in error.message
-
-
-async def test_evaluate_return_complex_objects(page):
-    obj = {"foo": "bar!"}
-    result = await page.evaluate("a => a", obj)
-    assert result == obj
-
-
-async def test_evaluate_accept_none_as_one_of_multiple_parameters(page):
-    result = await page.evaluate(
-        '({ a, b }) => Object.is(a, undefined) && Object.is(b, "foo")',
-        {"a": None, "b": "foo"},
-    )
-    assert result
-
-
-async def test_evaluate_properly_serialize_none_arguments(page):
-    assert await page.evaluate("x => ({a: x})", None) == {"a": None}
-
-
-async def test_evaluate_fail_for_circular_object(page):
-    assert (
-        await page.evaluate(
-            """() => {
-                const a = {};
-                const b = {a};
-                a.b = b;
-                return a;
-            }"""
-        )
-        is None
-    )
-
-
-async def test_evaluate_accept_string(page):
-    assert await page.evaluate("1 + 2") == 3
-
-
-async def test_evaluate_accept_element_handle_as_an_argument(page):
-    await page.set_content("<section>42</section>")
-    element = await page.query_selector("section")
-    text = await page.evaluate("e => e.textContent", element)
-    assert text == "42"
-
-
-async def test_evaluate_throw_if_underlying_element_was_disposed(page):
-    await page.set_content("<section>39</section>")
-    element = await page.query_selector("section")
-    await element.dispose()
-    error = None
-    try:
-        await page.evaluate("e => e.textContent", element)
-    except Error as e:
-        error = e
-    assert "JSHandle is disposed" in error.message
-
-
-async def test_evaluate_evaluate_exception(page):
-    error = await page.evaluate('new Error("error message")')
-    assert "Error: error message" in error
-
-
-async def test_evaluate_evaluate_date(page):
-    result = await page.evaluate(
-        '() => ({ date: new Date("2020-05-27T01:31:38.506Z") })'
-    )
-    assert result == {"date": datetime.fromisoformat("2020-05-27T01:31:38.506")}
-
-
-async def test_evaluate_roundtrip_date(page):
-    date = datetime.fromisoformat("2020-05-27T01:31:38.506")
-    result = await page.evaluate("date => date", date)
-    assert result == date
-
-
-async def test_evaluate_jsonvalue_date(page):
-    date = datetime.fromisoformat("2020-05-27T01:31:38.506")
-    result = await page.evaluate(
-        '() => ({ date: new Date("2020-05-27T01:31:38.506Z") })'
-    )
-    assert result == {"date": date}
diff --git a/tests/async/test_expect_misc.py b/tests/async/test_expect_misc.py
new file mode 100644
index 000000000..2148b0d9e
--- /dev/null
+++ b/tests/async/test_expect_misc.py
@@ -0,0 +1,80 @@
+# 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 pytest
+
+from playwright.async_api import Page, TimeoutError, expect
+from tests.server import Server
+
+
+async def test_to_be_in_viewport_should_work(page: Page, server: Server) -> None:
+    await page.set_content(
+        """
+      <div id=big style="height: 10000px;"></div>
+      <div id=small>foo</div>
+    """
+    )
+    await expect(page.locator("#big")).to_be_in_viewport()
+    await expect(page.locator("#small")).not_to_be_in_viewport()
+    await page.locator("#small").scroll_into_view_if_needed()
+    await expect(page.locator("#small")).to_be_in_viewport()
+    await expect(page.locator("#small")).to_be_in_viewport(ratio=1)
+
+
+async def test_to_be_in_viewport_should_respect_ratio_option(
+    page: Page, server: Server
+) -> None:
+    await page.set_content(
+        """
+      <style>body, div, html { padding: 0; margin: 0; }</style>
+      <div id=big style="height: 400vh;"></div>
+    """
+    )
+    await expect(page.locator("div")).to_be_in_viewport()
+    await expect(page.locator("div")).to_be_in_viewport(ratio=0.1)
+    await expect(page.locator("div")).to_be_in_viewport(ratio=0.2)
+
+    await expect(page.locator("div")).to_be_in_viewport(ratio=0.25)
+    # In this test, element's ratio is 0.25.
+    await expect(page.locator("div")).not_to_be_in_viewport(ratio=0.26)
+
+    await expect(page.locator("div")).not_to_be_in_viewport(ratio=0.3)
+    await expect(page.locator("div")).not_to_be_in_viewport(ratio=0.7)
+    await expect(page.locator("div")).not_to_be_in_viewport(ratio=0.8)
+
+
+async def test_to_be_in_viewport_should_have_good_stack(
+    page: Page, server: Server
+) -> None:
+    with pytest.raises(AssertionError) as exc_info:
+        await expect(page.locator("body")).not_to_be_in_viewport(timeout=1000)
+    assert 'unexpected value "viewport ratio' in str(exc_info.value)
+
+
+async def test_to_be_in_viewport_should_report_intersection_even_if_fully_covered_by_other_element(
+    page: Page, server: Server
+) -> None:
+    await page.set_content(
+        """
+      <h1>hello</h1>
+      <div style="position: relative; height: 10000px; top: -5000px;></div>
+    """
+    )
+    await expect(page.locator("h1")).to_be_in_viewport()
+
+
+async def test_should_have_timeout_error_name(page: Page) -> None:
+    with pytest.raises(TimeoutError) as exc_info:
+        await page.wait_for_selector("#not-found", timeout=1)
+    assert exc_info.value.name == "TimeoutError"
diff --git a/tests/async/test_extension.py b/tests/async/test_extension.py
new file mode 100644
index 000000000..853afd8a5
--- /dev/null
+++ b/tests/async/test_extension.py
@@ -0,0 +1,125 @@
+# 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 asyncio
+from pathlib import Path
+from typing import Any, AsyncGenerator, Awaitable, Callable, Dict, List, Optional
+
+import pytest
+
+from playwright.async_api import BrowserContext, BrowserType
+
+from ..server import Server
+
+
+@pytest.fixture()
+async def launch_persistent_context(
+    browser_type: BrowserType,
+    browser_channel: Optional[str],
+    tmp_path: Path,
+    launch_arguments: Dict[str, Any],
+    is_headless_shell: bool,
+) -> AsyncGenerator[Callable[..., Awaitable[BrowserContext]], None]:
+    if browser_channel and browser_channel.startswith("chrome"):
+        pytest.skip(
+            "--load-extension is not supported in Chrome anymore. https://groups.google.com/a/chromium.org/g/chromium-extensions/c/1-g8EFx2BBY/m/S0ET5wPjCAAJ"
+        )
+    if is_headless_shell:
+        pytest.skip("Headless Shell has no support for extensions")
+
+    contexts: List[BrowserContext] = []
+
+    async def launch(extension_path: str, **kwargs: Any) -> BrowserContext:
+        context = await browser_type.launch_persistent_context(
+            str(tmp_path),
+            **launch_arguments,
+            **kwargs,
+            args=[
+                f"--disable-extensions-except={extension_path}",
+                f"--load-extension={extension_path}",
+            ],
+        )
+        contexts.append(context)
+        return context
+
+    yield launch
+
+    for context in contexts:
+        await context.close()
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_give_access_to_the_service_worker(
+    launch_persistent_context: Callable[..., Awaitable[BrowserContext]],
+    assetdir: Path,
+) -> None:
+    extension_path = str(assetdir / "extension-mv3-simple")
+    context = await launch_persistent_context(extension_path)
+    service_workers = context.service_workers
+    service_worker = (
+        service_workers[0]
+        if len(service_workers)
+        else await context.wait_for_event("serviceworker")
+    )
+    assert service_worker
+    assert service_worker in context.service_workers
+    while not await service_worker.evaluate("globalThis.MAGIC") == 42:
+        await context.pages[0].wait_for_timeout(100)
+    await context.close()
+    assert len(context.background_pages) == 0
+
+
+@pytest.mark.only_browser("chromium")
+async def test_should_give_access_to_the_service_worker_when_recording_video(
+    launch_persistent_context: Callable[..., Awaitable[BrowserContext]],
+    tmp_path: Path,
+    assetdir: Path,
+) -> None:
+    extension_path = str(assetdir / "extension-mv3-simple")
+    context = await launch_persistent_context(
+        extension_path, record_video_dir=(tmp_path / "videos")
+    )
+    service_workers = context.service_workers
+    service_worker = (
+        service_workers[0]
+        if len(service_workers)
+        else await context.wait_for_event("serviceworker")
+    )
+    assert service_worker
+    assert service_worker in context.service_workers
+    while not await service_worker.evaluate("globalThis.MAGIC") == 42:
+        await context.pages[0].wait_for_timeout(100)
+    await context.close()
+    assert len(context.background_pages) == 0
+
+
+# https://github.com/microsoft/playwright/issues/32762
+@pytest.mark.only_browser("chromium")
+async def test_should_report_console_messages_from_content_script(
+    launch_persistent_context: Callable[..., Awaitable[BrowserContext]],
+    assetdir: Path,
+    server: Server,
+) -> None:
+    extension_path = str(assetdir / "extension-mv3-with-logging")
+    context = await launch_persistent_context(extension_path)
+    page = await context.new_page()
+    [message, _] = await asyncio.gather(
+        page.context.wait_for_event(
+            "console",
+            lambda e: "Test console log from a third-party execution context" in e.text,
+        ),
+        page.goto(server.EMPTY_PAGE),
+    )
+    assert "Test console log from a third-party execution context" in message.text
+    await context.close()
diff --git a/tests/async/test_fetch_browser_context.py b/tests/async/test_fetch_browser_context.py
new file mode 100644
index 000000000..f61f12eb0
--- /dev/null
+++ b/tests/async/test_fetch_browser_context.py
@@ -0,0 +1,473 @@
+# 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 asyncio
+import base64
+import json
+from pathlib import Path
+from typing import Any, Callable, cast
+from urllib.parse import parse_qs
+
+import pytest
+
+from playwright.async_api import (
+    Browser,
+    BrowserContext,
+    Error,
+    FilePayload,
+    FormData,
+    Page,
+)
+from tests.server import Server, TestServerRequest
+from tests.utils import must
+
+
+async def test_get_should_work(context: BrowserContext, server: Server) -> None:
+    response = await context.request.get(server.PREFIX + "/simple.json")
+    assert response.url == server.PREFIX + "/simple.json"
+    assert response.status == 200
+    assert response.status_text == "OK"
+    assert response.ok is True
+    assert response.headers["content-type"] == "application/json"
+    assert {
+        "name": "Content-Type",
+        "value": "application/json",
+    } in response.headers_array
+    assert await response.text() == '{"foo": "bar"}\n'
+
+
+async def test_fetch_should_work(context: BrowserContext, server: Server) -> None:
+    response = await context.request.fetch(server.PREFIX + "/simple.json")
+    assert response.url == server.PREFIX + "/simple.json"
+    assert response.status == 200
+    assert response.status_text == "OK"
+    assert response.ok is True
+    assert response.headers["content-type"] == "application/json"
+    assert {
+        "name": "Content-Type",
+        "value": "application/json",
+    } in response.headers_array
+    assert await response.text() == '{"foo": "bar"}\n'
+
+
+async def test_should_throw_on_network_error(
+    context: BrowserContext, server: Server
+) -> None:
+    server.set_route("/test", lambda request: request.loseConnection())
+    with pytest.raises(Error, match="socket hang up"):
+        await context.request.fetch(server.PREFIX + "/test")
+
+
+async def test_should_add_session_cookies_to_request(
+    context: BrowserContext, server: Server
+) -> None:
+    await context.add_cookies(
+        [
+            {
+                "name": "username",
+                "value": "John Doe",
+                "url": server.EMPTY_PAGE,
+                "expires": -1,
+                "httpOnly": False,
+                "secure": False,
+                "sameSite": "Lax",
+            }
+        ]
+    )
+    [server_req, response] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        context.request.get(server.EMPTY_PAGE),
+    )
+    assert server_req.getHeader("Cookie") == "username=John Doe"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+async def test_should_support_query_params(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    expected_params = {"p1": "v1", "парам2": "знач2"}
+    [server_req, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        getattr(context.request, method)(
+            server.EMPTY_PAGE + "?p1=foo", params=expected_params
+        ),
+    )
+    assert list(map(lambda x: x.decode(), server_req.args["p1".encode()])) == [
+        "foo",
+        "v1",
+    ]
+    assert server_req.args["парам2".encode()][0].decode() == "знач2"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+async def test_should_support_params_passed_as_object(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    params = {
+        "param1": "value1",
+        "парам2": "знач2",
+    }
+    [server_req, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        getattr(context.request, method)(server.EMPTY_PAGE, params=params),
+    )
+    assert server_req.args["param1".encode()][0].decode() == "value1"
+    assert len(server_req.args["param1".encode()]) == 1
+    assert server_req.args["парам2".encode()][0].decode() == "знач2"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+async def test_should_support_params_passed_as_strings(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    params = "?param1=value1&param1=value2&парам2=знач2"
+    [server_req, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        getattr(context.request, method)(server.EMPTY_PAGE, params=params),
+    )
+    assert list(map(lambda x: x.decode(), server_req.args["param1".encode()])) == [
+        "value1",
+        "value2",
+    ]
+    assert len(server_req.args["param1".encode()]) == 2
+    assert server_req.args["парам2".encode()][0].decode() == "знач2"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+async def test_should_support_fail_on_status_code(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    with pytest.raises(Error, match="404 Not Found"):
+        await getattr(context.request, method)(
+            server.PREFIX + "/this-does-clearly-not-exist.html",
+            fail_on_status_code=True,
+        )
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+async def test_should_support_ignore_https_errors_option(
+    context: BrowserContext, https_server: Server, method: str
+) -> None:
+    response = await getattr(context.request, method)(
+        https_server.EMPTY_PAGE, ignore_https_errors=True
+    )
+    assert response.ok
+    assert response.status == 200
+
+
+async def test_should_not_add_context_cookie_if_cookie_header_passed_as_parameter(
+    context: BrowserContext, server: Server
+) -> None:
+    await context.add_cookies(
+        [
+            {
+                "name": "username",
+                "value": "John Doe",
+                "url": server.EMPTY_PAGE,
+                "expires": -1,
+                "httpOnly": False,
+                "secure": False,
+                "sameSite": "Lax",
+            }
+        ]
+    )
+    [server_req, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        context.request.get(server.EMPTY_PAGE, headers={"Cookie": "foo=bar"}),
+    )
+    assert server_req.getHeader("Cookie") == "foo=bar"
+
+
+async def test_should_support_http_credentials_send_immediately_for_browser_context(
+    context_factory: "Callable[..., asyncio.Future[BrowserContext]]", server: Server
+) -> None:
+    context = await context_factory(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.upper(),
+            "send": "always",
+        }
+    )
+    # First request
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"), context.request.get(server.EMPTY_PAGE)
+    )
+    expected_auth = "Basic " + base64.b64encode(b"user:pass").decode()
+    assert server_request.getHeader("authorization") == expected_auth
+    assert response.status == 200
+
+    # Second request
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        context.request.get(server.CROSS_PROCESS_PREFIX + "/empty.html"),
+    )
+    # Not sent to another origin.
+    assert server_request.getHeader("authorization") is None
+    assert response.status == 200
+
+
+async def test_support_http_credentials_send_immediately_for_browser_new_page(
+    server: Server, browser: Browser
+) -> None:
+    page = await browser.new_page(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.upper(),
+            "send": "always",
+        }
+    )
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"), page.request.get(server.EMPTY_PAGE)
+    )
+    assert (
+        server_request.getHeader("authorization")
+        == "Basic " + base64.b64encode(b"user:pass").decode()
+    )
+    assert response.status == 200
+
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        page.request.get(server.CROSS_PROCESS_PREFIX + "/empty.html"),
+    )
+    # Not sent to another origin.
+    assert server_request.getHeader("authorization") is None
+    assert response.status == 200
+
+    await page.close()
+
+
+@pytest.mark.parametrize("method", ["delete", "patch", "post", "put"])
+async def test_should_support_post_data(
+    context: BrowserContext, method: str, server: Server
+) -> None:
+    async def support_post_data(fetch_data: Any, request_post_data: Any) -> None:
+        [request, response] = await asyncio.gather(
+            server.wait_for_request("/simple.json"),
+            getattr(context.request, method)(
+                server.PREFIX + "/simple.json", data=fetch_data
+            ),
+        )
+        assert request.method.decode() == method.upper()
+        assert request.post_body == request_post_data
+        assert response.status == 200
+        assert response.url == server.PREFIX + "/simple.json"
+        assert request.getHeader("Content-Length") == str(len(must(request.post_body)))
+
+    await support_post_data("My request", "My request".encode())
+    await support_post_data(b"My request", "My request".encode())
+    await support_post_data(["my", "request"], json.dumps(["my", "request"]).encode())
+    await support_post_data({"my": "request"}, json.dumps({"my": "request"}).encode())
+    with pytest.raises(Error, match="Unsupported 'data' type: <class 'function'>"):
+        await support_post_data(lambda: None, None)
+
+
+async def test_should_support_application_x_www_form_urlencoded(
+    context: BrowserContext, server: Server
+) -> None:
+    [request, response] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        context.request.post(
+            server.PREFIX + "/empty.html",
+            form={
+                "firstName": "John",
+                "lastName": "Doe",
+                "file": "f.js",
+            },
+        ),
+    )
+    assert request.method == b"POST"
+    assert request.getHeader("Content-Type") == "application/x-www-form-urlencoded"
+    assert request.post_body
+    body = request.post_body.decode()
+    assert request.getHeader("Content-Length") == str(len(body))
+    params = parse_qs(request.post_body)
+    assert params[b"firstName"] == [b"John"]
+    assert params[b"lastName"] == [b"Doe"]
+    assert params[b"file"] == [b"f.js"]
+
+
+async def test_should_support_multipart_form_data(
+    context: BrowserContext, server: Server
+) -> None:
+    file: FilePayload = {
+        "name": "f.js",
+        "mimeType": "text/javascript",
+        "buffer": b"var x = 10;\r\n;console.log(x);",
+    }
+    [request, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        context.request.post(
+            server.PREFIX + "/empty.html",
+            multipart={
+                "firstName": "John",
+                "lastName": "Doe",
+                "file": file,
+            },
+        ),
+    )
+    assert request.method == b"POST"
+    assert cast(str, request.getHeader("Content-Type")).startswith(
+        "multipart/form-data; "
+    )
+    assert must(request.getHeader("Content-Length")) == str(
+        len(must(request.post_body))
+    )
+    assert request.args[b"firstName"] == [b"John"]
+    assert request.args[b"lastName"] == [b"Doe"]
+    assert request.args[b"file"][0] == file["buffer"]
+
+
+async def test_should_support_form_data_with_repeated_keys(
+    context: BrowserContext, server: Server
+) -> None:
+    form = FormData()
+    form.append("name", "John")
+    form.append("name", "Doe")
+    form.set("email", "john@example.com")
+    [request, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        context.request.post(server.EMPTY_PAGE, form=form),
+    )
+    assert request.getHeader("Content-Type") == "application/x-www-form-urlencoded"
+    params = parse_qs(must(request.post_body))
+    assert params[b"name"] == [b"John", b"Doe"]
+    assert params[b"email"] == [b"john@example.com"]
+
+
+async def test_should_support_form_data_set_overwrites_previous_values(
+    context: BrowserContext, server: Server
+) -> None:
+    form = FormData()
+    form.append("name", "first")
+    form.append("name", "second")
+    form.set("name", "final")
+    form.set("age", 30)
+    [request, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        context.request.post(server.EMPTY_PAGE, form=form),
+    )
+    params = parse_qs(must(request.post_body))
+    assert params[b"name"] == [b"final"]
+    assert params[b"age"] == [b"30"]
+
+
+async def test_should_reject_file_value_in_form(
+    context: BrowserContext, server: Server, tmp_path: Path
+) -> None:
+    file = tmp_path / "f.txt"
+    file.write_bytes(b"hello")
+    form = FormData()
+    form.set("attachment", file)
+    with pytest.raises(Error, match="Use 'multipart' for file uploads"):
+        await context.request.post(server.EMPTY_PAGE, form=form)
+
+
+async def test_should_support_multipart_form_data_with_multiple_files_in_one_field(
+    context: BrowserContext, server: Server
+) -> None:
+    file1: FilePayload = {
+        "name": "f1.txt",
+        "mimeType": "text/plain",
+        "buffer": b"file 1 content",
+    }
+    file2: FilePayload = {
+        "name": "f2.txt",
+        "mimeType": "text/plain",
+        "buffer": b"file 2 content",
+    }
+    form = FormData()
+    form.append("files", file1)
+    form.append("files", file2)
+    form.set("user", "alice")
+    [request, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        context.request.post(server.EMPTY_PAGE, multipart=form),
+    )
+    assert cast(str, request.getHeader("Content-Type")).startswith(
+        "multipart/form-data; "
+    )
+    assert request.args[b"user"] == [b"alice"]
+    assert request.args[b"files"] == [file1["buffer"], file2["buffer"]]
+
+
+async def test_should_support_multipart_form_data_with_path_value(
+    context: BrowserContext, server: Server, tmp_path: Path
+) -> None:
+    file = tmp_path / "data.csv"
+    file.write_bytes(b"a,b,c\n1,2,3\n")
+    form = FormData()
+    form.set("attachment", file)
+    [request, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        context.request.post(server.EMPTY_PAGE, multipart=form),
+    )
+    assert cast(str, request.getHeader("Content-Type")).startswith(
+        "multipart/form-data; "
+    )
+    assert request.args[b"attachment"] == [b"a,b,c\n1,2,3\n"]
+
+
+async def test_should_add_default_headers(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    [request, response] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        context.request.get(server.EMPTY_PAGE),
+    )
+    assert request.getHeader("Accept") == "*/*"
+    assert request.getHeader("Accept-Encoding") == "gzip,deflate,br"
+    assert request.getHeader("User-Agent") == await page.evaluate(
+        "() => navigator.userAgent"
+    )
+
+
+async def test_should_work_after_context_dispose(
+    context: BrowserContext, server: Server
+) -> None:
+    await context.close(reason="Test ended.")
+    with pytest.raises(Error, match="Test ended."):
+        await context.request.get(server.EMPTY_PAGE)
+
+
+async def test_should_retry_ECONNRESET(context: BrowserContext, server: Server) -> None:
+    request_count = 0
+
+    def _handle_request(req: TestServerRequest) -> None:
+        nonlocal request_count
+        request_count += 1
+        if request_count <= 3:
+            assert req.transport
+            req.transport.abortConnection()
+            return
+        req.setHeader("content-type", "text/plain")
+        req.write(b"Hello!")
+        req.finish()
+
+    server.set_route("/test", _handle_request)
+    response = await context.request.fetch(server.PREFIX + "/test", max_retries=3)
+    assert response.status == 200
+    assert await response.text() == "Hello!"
+    assert request_count == 4
diff --git a/tests/async/test_fetch_global.py b/tests/async/test_fetch_global.py
new file mode 100644
index 000000000..1f7593194
--- /dev/null
+++ b/tests/async/test_fetch_global.py
@@ -0,0 +1,555 @@
+# 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 asyncio
+import base64
+import json
+import sys
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+import pytest
+
+from playwright.async_api import APIResponse, Error, Playwright, StorageState
+from tests.server import Server, TestServerRequest
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+async def test_should_work(playwright: Playwright, method: str, server: Server) -> None:
+    request = await playwright.request.new_context()
+    response: APIResponse = await getattr(request, method)(
+        server.PREFIX + "/simple.json"
+    )
+    assert response.status == 200
+    assert response.status_text == "OK"
+    assert response.ok is True
+    assert response.url == server.PREFIX + "/simple.json"
+    assert response.headers["content-type"] == "application/json"
+    assert {
+        "name": "Content-Type",
+        "value": "application/json",
+    } in response.headers_array
+    assert await response.text() == ("" if method == "head" else '{"foo": "bar"}\n')
+
+
+async def test_should_dispose_global_request(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context()
+    response = await request.get(server.PREFIX + "/simple.json")
+    assert await response.json() == {"foo": "bar"}
+    await response.dispose()
+    with pytest.raises(Error, match="Response has been disposed"):
+        await response.body()
+
+
+async def test_should_dispose_with_custom_error_message(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context()
+    await request.dispose(reason="My reason")
+    with pytest.raises(Error, match="My reason"):
+        await request.get(server.EMPTY_PAGE)
+
+
+async def test_should_support_global_user_agent_option(
+    playwright: Playwright, server: Server
+) -> None:
+    api_request_context = await playwright.request.new_context(user_agent="My Agent")
+    response = await api_request_context.get(server.PREFIX + "/empty.html")
+    [request, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        api_request_context.get(server.EMPTY_PAGE),
+    )
+    assert response.ok is True
+    assert response.url == server.EMPTY_PAGE
+    assert request.getHeader("user-agent") == "My Agent"
+
+
+async def test_should_support_global_timeout_option(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context(timeout=100)
+    server.set_route("/empty.html", lambda req: None)
+    with pytest.raises(Error, match="Timeout 100ms exceeded"):
+        await request.get(server.EMPTY_PAGE)
+
+
+async def test_should_support_timeout_option_in_get_method(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context()
+    server.set_route("/empty.html", lambda req: None)
+    with pytest.raises(Error, match="APIRequestContext.get: Timeout 123ms exceeded."):
+        await request.get(server.EMPTY_PAGE, timeout=123)
+
+
+async def test_should_propagate_extra_http_headers_with_redirects(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_redirect("/a/redirect1", "/b/c/redirect2")
+    server.set_redirect("/b/c/redirect2", "/simple.json")
+    request = await playwright.request.new_context(
+        extra_http_headers={"My-Secret": "Value"}
+    )
+    [req1, req2, req3, _] = await asyncio.gather(
+        server.wait_for_request("/a/redirect1"),
+        server.wait_for_request("/b/c/redirect2"),
+        server.wait_for_request("/simple.json"),
+        request.get(f"{server.PREFIX}/a/redirect1"),
+    )
+    assert req1.getHeader("my-secret") == "Value"
+    assert req2.getHeader("my-secret") == "Value"
+    assert req3.getHeader("my-secret") == "Value"
+
+
+async def test_should_support_global_http_credentials_option(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    request1 = await playwright.request.new_context()
+    response1 = await request1.get(server.EMPTY_PAGE)
+    assert response1.status == 401
+    await response1.dispose()
+
+    request2 = await playwright.request.new_context(
+        http_credentials={"username": "user", "password": "pass"}
+    )
+    response2 = await request2.get(server.EMPTY_PAGE)
+    assert response2.status == 200
+    assert response2.ok is True
+    await response2.dispose()
+
+
+async def test_should_return_error_with_wrong_credentials(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    request = await playwright.request.new_context(
+        http_credentials={"username": "user", "password": "wrong"}
+    )
+    response = await request.get(server.EMPTY_PAGE)
+    assert response.status == 401
+    assert response.ok is False
+
+
+async def test_should_work_with_correct_credentials_and_matching_origin(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    request = await playwright.request.new_context(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX,
+        }
+    )
+    response = await request.get(server.EMPTY_PAGE)
+    assert response.status == 200
+    await response.dispose()
+
+
+async def test_should_work_with_correct_credentials_and_matching_origin_case_insensitive(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    request = await playwright.request.new_context(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.upper(),
+        }
+    )
+    response = await request.get(server.EMPTY_PAGE)
+    assert response.status == 200
+    await response.dispose()
+
+
+async def test_should_return_error_with_correct_credentials_and_mismatching_scheme(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    request = await playwright.request.new_context(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.replace("http://", "https://"),
+        }
+    )
+    response = await request.get(server.EMPTY_PAGE)
+    assert response.status == 401
+    await response.dispose()
+
+
+async def test_should_return_error_with_correct_credentials_and_mismatching_hostname(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    hostname = urlparse(server.PREFIX).hostname
+    assert hostname
+    origin = server.PREFIX.replace(hostname, "mismatching-hostname")
+    request = await playwright.request.new_context(
+        http_credentials={"username": "user", "password": "pass", "origin": origin}
+    )
+    response = await request.get(server.EMPTY_PAGE)
+    assert response.status == 401
+    await response.dispose()
+
+
+async def test_should_return_error_with_correct_credentials_and_mismatching_port(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    origin = server.PREFIX.replace(str(server.PORT), str(server.PORT + 1))
+    request = await playwright.request.new_context(
+        http_credentials={"username": "user", "password": "pass", "origin": origin}
+    )
+    response = await request.get(server.EMPTY_PAGE)
+    assert response.status == 401
+    await response.dispose()
+
+
+async def test_support_http_credentials_send_immediately(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.upper(),
+            "send": "always",
+        }
+    )
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"), request.get(server.EMPTY_PAGE)
+    )
+    assert (
+        server_request.getHeader("authorization")
+        == "Basic " + base64.b64encode(b"user:pass").decode()
+    )
+    assert response.status == 200
+
+    server_request, response = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        request.get(server.CROSS_PROCESS_PREFIX + "/empty.html"),
+    )
+    # Not sent to another origin.
+    assert server_request.getHeader("authorization") is None
+    assert response.status == 200
+
+
+async def test_should_support_global_ignore_https_errors_option(
+    playwright: Playwright, https_server: Server
+) -> None:
+    request = await playwright.request.new_context(ignore_https_errors=True)
+    response = await request.get(https_server.EMPTY_PAGE)
+    assert response.status == 200
+    assert response.ok is True
+    assert response.url == https_server.EMPTY_PAGE
+    await response.dispose()
+
+
+async def test_should_resolve_url_relative_to_global_base_url_option(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context(base_url=server.PREFIX)
+    response = await request.get("/empty.html")
+    assert response.status == 200
+    assert response.ok is True
+    assert response.url == server.EMPTY_PAGE
+    await response.dispose()
+
+
+async def test_should_use_playwright_as_a_user_agent(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context()
+    [server_req, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        request.get(server.EMPTY_PAGE),
+    )
+    assert str(server_req.getHeader("User-Agent")).startswith("Playwright/")
+    await request.dispose()
+
+
+async def test_should_return_empty_body(playwright: Playwright, server: Server) -> None:
+    request = await playwright.request.new_context()
+    response = await request.get(server.EMPTY_PAGE)
+    body = await response.body()
+    assert len(body) == 0
+    assert await response.text() == ""
+    await request.dispose()
+    with pytest.raises(Error, match="Response has been disposed"):
+        await response.body()
+
+
+async def test_storage_state_should_round_trip_through_file(
+    playwright: Playwright, tmp_path: Path
+) -> None:
+    expected: StorageState = {
+        "cookies": [
+            {
+                "name": "a",
+                "value": "b",
+                "domain": "a.b.one.com",
+                "path": "/",
+                "expires": -1,
+                "httpOnly": False,
+                "secure": False,
+                "sameSite": "Lax",
+            }
+        ],
+        "origins": [],
+    }
+    request = await playwright.request.new_context(storage_state=expected)
+    path = tmp_path / "storage-state.json"
+    actual = await request.storage_state(path=path)
+    assert actual == expected
+
+    written = path.read_text("utf8")
+    assert json.loads(written) == expected
+
+    request2 = await playwright.request.new_context(storage_state=path)
+    state2 = await request2.storage_state()
+    assert state2 == expected
+
+
+serialization_data = [
+    [{"foo": "bar"}],
+    [["foo", "bar", 2021]],
+    ["foo"],
+    [True],
+    [2021],
+]
+
+
+@pytest.mark.parametrize("serialization", serialization_data)
+async def test_should_json_stringify_body_when_content_type_is_application_json(
+    playwright: Playwright, server: Server, serialization: Any
+) -> None:
+    request = await playwright.request.new_context()
+    [req, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        request.post(
+            server.EMPTY_PAGE,
+            headers={"content-type": "application/json"},
+            data=serialization,
+        ),
+    )
+    body = req.post_body
+    assert body
+    assert body.decode() == json.dumps(serialization)
+    await request.dispose()
+
+
+@pytest.mark.parametrize("serialization", serialization_data)
+async def test_should_not_double_stringify_body_when_content_type_is_application_json(
+    playwright: Playwright, server: Server, serialization: Any
+) -> None:
+    request = await playwright.request.new_context()
+    stringified_value = json.dumps(serialization)
+    [req, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        request.post(
+            server.EMPTY_PAGE,
+            headers={"content-type": "application/json"},
+            data=stringified_value,
+        ),
+    )
+
+    body = req.post_body
+    assert body
+    assert body.decode() == stringified_value
+    await request.dispose()
+
+
+async def test_should_accept_already_serialized_data_as_bytes_when_content_type_is_application_json(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context()
+    stringified_value = json.dumps({"foo": "bar"}).encode()
+    [req, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        request.post(
+            server.EMPTY_PAGE,
+            headers={"content-type": "application/json"},
+            data=stringified_value,
+        ),
+    )
+    body = req.post_body
+    assert body == stringified_value
+    await request.dispose()
+
+
+async def test_should_contain_default_user_agent(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context()
+    [server_request, _] = await asyncio.gather(
+        server.wait_for_request("/empty.html"),
+        request.get(server.EMPTY_PAGE),
+    )
+    user_agent = server_request.getHeader("user-agent")
+    assert user_agent
+    assert "python" in user_agent
+    assert f"{sys.version_info.major}.{sys.version_info.minor}" in user_agent
+
+
+async def test_should_throw_an_error_when_max_redirects_is_exceeded(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_redirect("/a/redirect1", "/b/c/redirect2")
+    server.set_redirect("/b/c/redirect2", "/b/c/redirect3")
+    server.set_redirect("/b/c/redirect3", "/b/c/redirect4")
+    server.set_redirect("/b/c/redirect4", "/simple.json")
+
+    request = await playwright.request.new_context()
+    for method in ["GET", "PUT", "POST", "OPTIONS", "HEAD", "PATCH"]:
+        for max_redirects in [1, 2, 3]:
+            with pytest.raises(Error) as exc_info:
+                await request.fetch(
+                    server.PREFIX + "/a/redirect1",
+                    method=method,
+                    max_redirects=max_redirects,
+                )
+            assert "Max redirect count exceeded" in str(exc_info)
+
+
+async def test_should_not_follow_redirects_when_max_redirects_is_set_to_0(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_redirect("/a/redirect1", "/b/c/redirect2")
+    server.set_redirect("/b/c/redirect2", "/simple.json")
+
+    request = await playwright.request.new_context()
+    for method in ["GET", "PUT", "POST", "OPTIONS", "HEAD", "PATCH"]:
+        response = await request.fetch(
+            server.PREFIX + "/a/redirect1", method=method, max_redirects=0
+        )
+        assert response.headers["location"] == "/b/c/redirect2"
+        assert response.status == 302
+
+
+async def test_should_throw_an_error_when_max_redirects_is_less_than_0(
+    playwright: Playwright,
+    server: Server,
+) -> None:
+    request = await playwright.request.new_context()
+    for method in ["GET", "PUT", "POST", "OPTIONS", "HEAD", "PATCH"]:
+        with pytest.raises(AssertionError) as exc_info:
+            await request.fetch(
+                server.PREFIX + "/a/redirect1", method=method, max_redirects=-1
+            )
+        assert "'max_redirects' must be greater than or equal to '0'" in str(exc_info)
+
+
+async def test_should_serialize_request_data(
+    playwright: Playwright, server: Server
+) -> None:
+    request = await playwright.request.new_context()
+    server.set_route("/echo", lambda req: (req.write(req.post_body), req.finish()))
+    for data, expected in [
+        ({"foo": None}, '{"foo": null}'),
+        ([], "[]"),
+        ({}, "{}"),
+        ("", ""),
+    ]:
+        response = await request.post(server.PREFIX + "/echo", data=data)
+        assert response.status == 200
+        assert await response.text() == expected
+    await request.dispose()
+
+
+async def test_should_retry_ECONNRESET(playwright: Playwright, server: Server) -> None:
+    request_count = 0
+
+    def _handle_request(req: TestServerRequest) -> None:
+        nonlocal request_count
+        request_count += 1
+        if request_count <= 3:
+            assert req.transport
+            req.transport.abortConnection()
+            return
+        req.setHeader("content-type", "text/plain")
+        req.write(b"Hello!")
+        req.finish()
+
+    server.set_route("/test", _handle_request)
+    request = await playwright.request.new_context()
+    response = await request.fetch(server.PREFIX + "/test", max_retries=3)
+    assert response.status == 200
+    assert await response.text() == "Hello!"
+    assert request_count == 4
+    await request.dispose()
+
+
+async def test_should_throw_when_fail_on_status_code_is_true(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_route(
+        "/empty.html",
+        lambda req: (
+            req.setResponseCode(404),
+            req.setHeader("Content-Length", "10"),
+            req.setHeader("Content-Type", "text/plain"),
+            req.write(b"Not found."),
+            req.finish(),
+        ),
+    )
+    request = await playwright.request.new_context(fail_on_status_code=True)
+    with pytest.raises(Error, match="404 Not Found"):
+        await request.fetch(server.EMPTY_PAGE)
+    await request.dispose()
+
+
+async def test_should_not_throw_when_fail_on_status_code_is_false(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_route(
+        "/empty.html",
+        lambda req: (
+            req.setResponseCode(404),
+            req.setHeader("Content-Length", "10"),
+            req.setHeader("Content-Type", "text/plain"),
+            req.write(b"Not found."),
+            req.finish(),
+        ),
+    )
+    request = await playwright.request.new_context(fail_on_status_code=False)
+    response = await request.fetch(server.EMPTY_PAGE)
+    assert response.status == 404
+    await request.dispose()
+
+
+async def test_should_follow_max_redirects(
+    playwright: Playwright, server: Server
+) -> None:
+    redirect_count = 0
+
+    def _handle_request(req: TestServerRequest) -> None:
+        nonlocal redirect_count
+        redirect_count += 1
+        req.setResponseCode(301)
+        req.setHeader("Location", server.EMPTY_PAGE)
+        req.finish()
+
+    server.set_route("/empty.html", _handle_request)
+    request = await playwright.request.new_context(max_redirects=1)
+    with pytest.raises(Error, match="Max redirect count exceeded"):
+        await request.fetch(server.EMPTY_PAGE)
+    assert redirect_count == 2
+    await request.dispose()
diff --git a/tests/async/test_fill.py b/tests/async/test_fill.py
index 9e5d252f0..c5f0a55be 100644
--- a/tests/async/test_fill.py
+++ b/tests/async/test_fill.py
@@ -12,14 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from playwright.async_api import Page
+from tests.server import Server
 
-async def test_fill_textarea(page, server):
+
+async def test_fill_textarea(page: Page, server: Server) -> None:
     await page.goto(f"{server.PREFIX}/input/textarea.html")
     await page.fill("textarea", "some value")
     assert await page.evaluate("result") == "some value"
 
 
-async def test_fill_input(page, server):
+async def test_is_enabled_for_non_editable_button(page: Page) -> None:
+    await page.set_content(
+        """
+        <button>button</button>
+    """
+    )
+    button = page.locator("button")
+    assert await button.is_enabled() is True
+
+
+async def test_fill_input(page: Page, server: Server) -> None:
     await page.goto(f"{server.PREFIX}/input/textarea.html")
     await page.fill("input", "some value")
     assert await page.evaluate("result") == "some value"
diff --git a/tests/async/test_focus.py b/tests/async/test_focus.py
index 33ec971d0..72698ea85 100644
--- a/tests/async/test_focus.py
+++ b/tests/async/test_focus.py
@@ -14,15 +14,17 @@
 
 import pytest
 
+from playwright.async_api import Page
 
-async def test_should_work(page):
+
+async def test_should_work(page: Page) -> None:
     await page.set_content("<div id=d1 tabIndex=0></div>")
     assert await page.evaluate("() => document.activeElement.nodeName") == "BODY"
     await page.focus("#d1")
     assert await page.evaluate("() => document.activeElement.id") == "d1"
 
 
-async def test_should_emit_focus_event(page):
+async def test_should_emit_focus_event(page: Page) -> None:
     await page.set_content("<div id=d1 tabIndex=0></div>")
     focused = []
     await page.expose_function("focusEvent", lambda: focused.append(True))
@@ -31,7 +33,7 @@ async def test_should_emit_focus_event(page):
     assert focused == [True]
 
 
-async def test_should_emit_blur_event(page):
+async def test_should_emit_blur_event(page: Page) -> None:
     await page.set_content(
         "<div id=d1 tabIndex=0>DIV1</div><div id=d2 tabIndex=0>DIV2</div>"
     )
@@ -47,7 +49,7 @@ async def test_should_emit_blur_event(page):
     assert blurred == [True]
 
 
-async def test_should_traverse_focus(page):
+async def test_should_traverse_focus(page: Page) -> None:
     await page.set_content('<input id="i1"><input id="i2">')
     focused = []
     await page.expose_function("focusEvent", lambda: focused.append(True))
@@ -63,7 +65,7 @@ async def test_should_traverse_focus(page):
     assert await page.eval_on_selector("#i2", "e => e.value") == "Last"
 
 
-async def test_should_traverse_focus_in_all_directions(page):
+async def test_should_traverse_focus_in_all_directions(page: Page) -> None:
     await page.set_content('<input value="1"><input value="2"><input value="3">')
     await page.keyboard.press("Tab")
     assert await page.evaluate("() => document.activeElement.value") == "1"
@@ -79,11 +81,11 @@ async def test_should_traverse_focus_in_all_directions(page):
 
 @pytest.mark.only_platform("darwin")
 @pytest.mark.only_browser("webkit")
-async def test_should_traverse_only_form_elements(page):
+async def test_should_traverse_only_form_elements(page: Page) -> None:
     await page.set_content(
         """
       <input id="input-1">
-      <button id="button">buttton</button>
+      <button id="button">button</button>
       <a href id="link">link</a>
       <input id="input-2">
     """
diff --git a/tests/async/test_frames.py b/tests/async/test_frames.py
index db58ae703..e1d71a8e7 100644
--- a/tests/async/test_frames.py
+++ b/tests/async/test_frames.py
@@ -13,32 +13,45 @@
 # limitations under the License.
 
 import asyncio
+from typing import Optional
 
-from playwright.async_api import Error
+import pytest
 
+from playwright.async_api import Error, Page
+from tests.server import Server
 
-async def test_evaluate_handle(page, server):
+from .utils import Utils
+
+
+async def test_evaluate_handle(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     main_frame = page.main_frame
+    assert main_frame.page == page
     window_handle = await main_frame.evaluate_handle("window")
     assert window_handle
 
 
-async def test_frame_element(page, server, utils):
+async def test_frame_element(page: Page, server: Server, utils: Utils) -> None:
     await page.goto(server.EMPTY_PAGE)
     frame1 = await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
+    assert frame1
     await utils.attach_frame(page, "frame2", server.EMPTY_PAGE)
     frame3 = await utils.attach_frame(page, "frame3", server.EMPTY_PAGE)
+    assert frame3
     frame1handle1 = await page.query_selector("#frame1")
+    assert frame1handle1
     frame1handle2 = await frame1.frame_element()
     frame3handle1 = await page.query_selector("#frame3")
+    assert frame3handle1
     frame3handle2 = await frame3.frame_element()
     assert await frame1handle1.evaluate("(a, b) => a === b", frame1handle2)
     assert await frame3handle1.evaluate("(a, b) => a === b", frame3handle2)
     assert await frame1handle1.evaluate("(a, b) => a === b", frame3handle1) is False
 
 
-async def test_frame_element_with_content_frame(page, server, utils):
+async def test_frame_element_with_content_frame(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     frame = await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     handle = await frame.frame_element()
@@ -46,30 +59,39 @@ async def test_frame_element_with_content_frame(page, server, utils):
     assert content_frame == frame
 
 
-async def test_frame_element_throw_when_detached(page, server, utils):
+async def test_frame_element_throw_when_detached(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     frame1 = await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     await page.eval_on_selector("#frame1", "e => e.remove()")
-    error = None
+    error: Optional[Error] = None
     try:
         await frame1.frame_element()
     except Error as e:
         error = e
-    assert error.message == "Frame has been detached."
+    assert error
+    assert error.message == "Frame.frame_element: Frame has been detached."
 
 
-async def test_evaluate_throw_for_detached_frames(page, server, utils):
+async def test_evaluate_throw_for_detached_frames(
+    page: Page, server: Server, utils: Utils
+) -> None:
     frame1 = await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
+    assert frame1
     await utils.detach_frame(page, "frame1")
-    error = None
+    error: Optional[Error] = None
     try:
         await frame1.evaluate("7 * 8")
     except Error as e:
         error = e
-    assert "Execution Context is not available in detached frame" in error.message
+    assert error
+    assert "Frame was detached" in error.message
 
 
-async def test_evaluate_isolated_between_frames(page, server, utils):
+async def test_evaluate_isolated_between_frames(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     assert len(page.frames) == 2
@@ -86,7 +108,9 @@ async def test_evaluate_isolated_between_frames(page, server, utils):
     assert a2 == 2
 
 
-async def test_should_handle_nested_frames(page, server, utils):
+async def test_should_handle_nested_frames(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.PREFIX + "/frames/nested-frames.html")
     assert utils.dump_frames(page.main_frame) == [
         "http://localhost:<PORT>/frames/nested-frames.html",
@@ -98,8 +122,8 @@ async def test_should_handle_nested_frames(page, server, utils):
 
 
 async def test_should_send_events_when_frames_are_manipulated_dynamically(
-    page, server, utils
-):
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     # validate frameattached events
     attached_frames = []
@@ -123,37 +147,42 @@ async def test_should_send_events_when_frames_are_manipulated_dynamically(
     assert navigated_frames[0].url == server.EMPTY_PAGE
 
     # validate framedetached events
-    detached_frames = list()
+    detached_frames = []
     page.on("framedetached", lambda frame: detached_frames.append(frame))
     await utils.detach_frame(page, "frame1")
     assert len(detached_frames) == 1
     assert detached_frames[0].is_detached()
 
 
-async def test_framenavigated_when_navigating_on_anchor_urls(page, server):
+async def test_framenavigated_when_navigating_on_anchor_urls(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
-    await asyncio.gather(
-        page.goto(server.EMPTY_PAGE + "#foo"), page.wait_for_event("framenavigated")
-    )
+    async with page.expect_event("framenavigated"):
+        await page.goto(server.EMPTY_PAGE + "#foo")
     assert page.url == server.EMPTY_PAGE + "#foo"
 
 
-async def test_persist_main_frame_on_cross_process_navigation(page, server):
+async def test_persist_main_frame_on_cross_process_navigation(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     main_frame = page.main_frame
     await page.goto(server.CROSS_PROCESS_PREFIX + "/empty.html")
     assert page.main_frame == main_frame
 
 
-async def test_should_not_send_attach_detach_events_for_main_frame(page, server):
-    has_events = list()
+async def test_should_not_send_attach_detach_events_for_main_frame(
+    page: Page, server: Server
+) -> None:
+    has_events = []
     page.on("frameattached", lambda frame: has_events.append(True))
     page.on("framedetached", lambda frame: has_events.append(True))
     await page.goto(server.EMPTY_PAGE)
     assert has_events == []
 
 
-async def test_detach_child_frames_on_navigation(page, server):
+async def test_detach_child_frames_on_navigation(page: Page, server: Server) -> None:
     attached_frames = []
     detached_frames = []
     navigated_frames = []
@@ -174,7 +203,7 @@ async def test_detach_child_frames_on_navigation(page, server):
     assert len(navigated_frames) == 1
 
 
-async def test_framesets(page, server):
+async def test_framesets(page: Page, server: Server) -> None:
     attached_frames = []
     detached_frames = []
     navigated_frames = []
@@ -195,7 +224,7 @@ async def test_framesets(page, server):
     assert len(navigated_frames) == 1
 
 
-async def test_frame_from_inside_shadow_dom(page, server):
+async def test_frame_from_inside_shadow_dom(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/shadow.html")
     await page.evaluate(
         """async url => {
@@ -210,7 +239,7 @@ async def test_frame_from_inside_shadow_dom(page, server):
     assert page.frames[1].url == server.EMPTY_PAGE
 
 
-async def test_frame_name(page, server, utils):
+async def test_frame_name(page: Page, server: Server, utils: Utils) -> None:
     await utils.attach_frame(page, "theFrameId", server.EMPTY_PAGE)
     await page.evaluate(
         """url => {
@@ -227,7 +256,7 @@ async def test_frame_name(page, server, utils):
     assert page.frames[2].name == "theFrameName"
 
 
-async def test_frame_parent(page, server, utils):
+async def test_frame_parent(page: Page, server: Server, utils: Utils) -> None:
     await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     await utils.attach_frame(page, "frame2", server.EMPTY_PAGE)
     assert page.frames[0].parent_frame is None
@@ -236,8 +265,8 @@ async def test_frame_parent(page, server, utils):
 
 
 async def test_should_report_different_frame_instance_when_frame_re_attaches(
-    page, server, utils
-):
+    page: Page, server: Server, utils: Utils
+) -> None:
     frame1 = await utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
     await page.evaluate(
         """() => {
@@ -247,9 +276,23 @@ async def test_should_report_different_frame_instance_when_frame_re_attaches(
     )
 
     assert frame1.is_detached()
-    [frame2, _] = await asyncio.gather(
-        page.wait_for_event("frameattached"),
-        page.evaluate("() => document.body.appendChild(window.frame)"),
-    )
+    async with page.expect_event("frameattached") as frame2_info:
+        await page.evaluate("() => document.body.appendChild(window.frame)")
+
+    frame2 = await frame2_info.value
     assert frame2.is_detached() is False
     assert frame1 != frame2
+
+
+async def test_strict_mode(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content(
+        """
+        <button>Hello</button>
+        <button>Hello</button>
+    """
+    )
+    with pytest.raises(Error):
+        await page.text_content("button", strict=True)
+    with pytest.raises(Error):
+        await page.query_selector("button", strict=True)
diff --git a/tests/async/test_geolocation.py b/tests/async/test_geolocation.py
index d98fa4064..12b00a4fa 100644
--- a/tests/async/test_geolocation.py
+++ b/tests/async/test_geolocation.py
@@ -13,41 +13,42 @@
 # limitations under the License.
 
 
-import asyncio
-
 import pytest
 
-from playwright.async_api import BrowserContext, Error, Geolocation, Page
+from playwright.async_api import Browser, BrowserContext, Error, Page
+from tests.server import Server
 
 
-async def test_should_work(page: Page, server, context: BrowserContext):
+async def test_should_work(page: Page, server: Server, context: BrowserContext) -> None:
     await context.grant_permissions(["geolocation"])
     await page.goto(server.EMPTY_PAGE)
-    await context.set_geolocation(latitude=10, longitude=10)
+    await context.set_geolocation({"latitude": 10, "longitude": 10})
     geolocation = await page.evaluate(
         """() => new Promise(resolve => navigator.geolocation.getCurrentPosition(position => {
       resolve({latitude: position.coords.latitude, longitude: position.coords.longitude});
     }))"""
     )
-    assert geolocation == Geolocation(latitude=10, longitude=10)._to_json()
+    assert geolocation == {"latitude": 10, "longitude": 10}
 
 
-async def test_should_throw_when_invalid_longitude(context):
+async def test_should_throw_when_invalid_longitude(context: BrowserContext) -> None:
     with pytest.raises(Error) as exc:
-        await context.set_geolocation(latitude=10, longitude=200)
+        await context.set_geolocation({"latitude": 10, "longitude": 200})
     assert (
         "geolocation.longitude: precondition -180 <= LONGITUDE <= 180 failed."
         in exc.value.message
     )
 
 
-async def test_should_isolate_contexts(page, server, context, browser):
+async def test_should_isolate_contexts(
+    page: Page, server: Server, context: BrowserContext, browser: Browser
+) -> None:
     await context.grant_permissions(["geolocation"])
-    await context.set_geolocation(latitude=10, longitude=10)
+    await context.set_geolocation({"latitude": 10, "longitude": 10})
     await page.goto(server.EMPTY_PAGE)
 
     context2 = await browser.new_context(
-        permissions=["geolocation"], geolocation=Geolocation(latitude=20, longitude=20)
+        permissions=["geolocation"], geolocation={"latitude": 10.5, "longitude": 10.5}
     )
 
     page2 = await context2.new_page()
@@ -58,24 +59,22 @@ async def test_should_isolate_contexts(page, server, context, browser):
       resolve({latitude: position.coords.latitude, longitude: position.coords.longitude})
     }))"""
     )
-    assert geolocation == Geolocation(latitude=10, longitude=10)._to_json()
+    assert geolocation == {"latitude": 10, "longitude": 10}
 
     geolocation2 = await page2.evaluate(
         """() => new Promise(resolve => navigator.geolocation.getCurrentPosition(position => {
       resolve({latitude: position.coords.latitude, longitude: position.coords.longitude})
     }))"""
     )
-    assert geolocation2 == Geolocation(latitude=20, longitude=20)._to_json()
+    assert geolocation2 == {"latitude": 10.5, "longitude": 10.5}
 
     await context2.close()
 
 
-async def test_should_use_context_options(browser, server):
-    options = {
-        "geolocation": Geolocation(latitude=10, longitude=10),
-        "permissions": ["geolocation"],
-    }
-    context = await browser.new_context(**options)
+async def test_should_use_context_options(browser: Browser, server: Server) -> None:
+    context = await browser.new_context(
+        geolocation={"latitude": 10, "longitude": 10}, permissions=["geolocation"]
+    )
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
 
@@ -84,17 +83,19 @@ async def test_should_use_context_options(browser, server):
       resolve({latitude: position.coords.latitude, longitude: position.coords.longitude});
     }))"""
     )
-    assert geolocation == Geolocation(latitude=10, longitude=10)._to_json()
+    assert geolocation == {"latitude": 10, "longitude": 10}
     await context.close()
 
 
-async def test_watchPosition_should_be_notified(page, server, context):
+async def test_watch_position_should_be_notified(
+    page: Page, server: Server, context: BrowserContext
+) -> None:
     await context.grant_permissions(["geolocation"])
     await page.goto(server.EMPTY_PAGE)
     messages = []
     page.on("console", lambda message: messages.append(message.text))
 
-    await context.set_geolocation(latitude=0, longitude=0)
+    await context.set_geolocation({"latitude": 0, "longitude": 0})
     await page.evaluate(
         """() => {
       navigator.geolocation.watchPosition(pos => {
@@ -104,33 +105,32 @@ async def test_watchPosition_should_be_notified(page, server, context):
     }"""
     )
 
-    await context.set_geolocation(latitude=0, longitude=10)
-    await page.wait_for_event("console", lambda message: "lat=0 lng=10" in message.text)
-    await context.set_geolocation(latitude=20, longitude=30)
-    await page.wait_for_event(
-        "console", lambda message: "lat=20 lng=30" in message.text
-    )
-    await context.set_geolocation(latitude=40, longitude=50)
-    await page.wait_for_event(
-        "console", lambda message: "lat=40 lng=50" in message.text
-    )
+    async with page.expect_console_message(lambda m: "lat=0 lng=10" in m.text):
+        await context.set_geolocation({"latitude": 0, "longitude": 10})
 
-    allMessages = "|".join(messages)
-    "latitude=0 lng=10" in allMessages
-    "latitude=20 lng=30" in allMessages
-    "latitude=40 lng=50" in allMessages
+    async with page.expect_console_message(lambda m: "lat=20 lng=30" in m.text):
+        await context.set_geolocation({"latitude": 20, "longitude": 30})
 
+    async with page.expect_console_message(lambda m: "lat=40 lng=50" in m.text):
+        await context.set_geolocation({"latitude": 40, "longitude": 50})
 
-async def test_should_use_context_options_for_popup(page, context, server):
+    all_messages = "|".join(messages)
+    assert "lat=0 lng=10" in all_messages
+    assert "lat=20 lng=30" in all_messages
+    assert "lat=40 lng=50" in all_messages
+
+
+async def test_should_use_context_options_for_popup(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
     await context.grant_permissions(["geolocation"])
-    await context.set_geolocation(latitude=10, longitude=10)
-    [popup, _] = await asyncio.gather(
-        page.wait_for_event("popup"),
-        page.evaluate(
+    await context.set_geolocation({"latitude": 10, "longitude": 10})
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
             "url => window._popup = window.open(url)",
             server.PREFIX + "/geolocation.html",
-        ),
-    )
+        )
+    popup = await popup_info.value
     await popup.wait_for_load_state()
     geolocation = await popup.evaluate("() => window.geolocationPromise")
-    assert geolocation == Geolocation(latitude=10, longitude=10)._to_json()
+    assert geolocation == {"latitude": 10, "longitude": 10}
diff --git a/tests/async/test_har.py b/tests/async/test_har.py
index 17bdfca52..0ea5ee054 100644
--- a/tests/async/test_har.py
+++ b/tests/async/test_har.py
@@ -12,13 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import base64
+import asyncio
 import json
 import os
+import re
+import zipfile
+from pathlib import Path
+from typing import Awaitable, Callable, cast
 
+import pytest
 
-async def test_should_work(browser, server, tmpdir):
-    path = os.path.join(tmpdir, "log.har")
+from playwright.async_api import Browser, BrowserContext, Error, Page, Route, expect
+from tests.server import Server, TestServerRequest
+from tests.utils import must
+
+
+async def test_should_work(browser: Browser, server: Server, tmp_path: Path) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(record_har_path=path)
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
@@ -28,10 +38,13 @@ async def test_should_work(browser, server, tmpdir):
         assert "log" in data
 
 
-async def test_should_omit_content(browser, server, tmpdir):
-    path = os.path.join(tmpdir, "log.har")
+async def test_should_omit_content(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(
-        record_har_path=path, record_har_omit_content=True
+        record_har_path=path,
+        record_har_content="omit",
     )
     page = await context.new_page()
     await page.goto(server.PREFIX + "/har.html")
@@ -40,13 +53,109 @@ async def test_should_omit_content(browser, server, tmpdir):
         data = json.load(f)
         assert "log" in data
         log = data["log"]
+        content1 = log["entries"][0]["response"]["content"]
+        assert "text" not in content1
+        assert "encoding" not in content1
+
 
+async def test_should_omit_content_legacy(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
+    context = await browser.new_context(
+        record_har_path=path, record_har_omit_content=True
+    )
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/har.html")
+    await context.close()
+    with open(path) as f:
+        data = json.load(f)
+        assert "log" in data
+        log = data["log"]
         content1 = log["entries"][0]["response"]["content"]
         assert "text" not in content1
+        assert "encoding" not in content1
+
+
+async def test_should_attach_content(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har.zip")
+    context = await browser.new_context(
+        record_har_path=path,
+        record_har_content="attach",
+    )
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/har.html")
+    await page.evaluate("() => fetch('/pptr.png').then(r => r.arrayBuffer())")
+    await context.close()
+    with zipfile.ZipFile(path) as z:
+        with z.open("har.har") as har:
+            entries = json.load(har)["log"]["entries"]
+
+            assert "encoding" not in entries[0]["response"]["content"]
+            assert (
+                entries[0]["response"]["content"]["mimeType"]
+                == "text/html; charset=utf-8"
+            )
+            assert (
+                "75841480e2606c03389077304342fac2c58ccb1b"
+                in entries[0]["response"]["content"]["_file"]
+            )
+            assert entries[0]["response"]["content"]["size"] >= 96
+            assert entries[0]["response"]["content"]["compression"] == 0
+
+            assert "encoding" not in entries[1]["response"]["content"]
+            assert (
+                entries[1]["response"]["content"]["mimeType"]
+                == "text/css; charset=utf-8"
+            )
+            assert (
+                "79f739d7bc88e80f55b9891a22bf13a2b4e18adb"
+                in entries[1]["response"]["content"]["_file"]
+            )
+            assert entries[1]["response"]["content"]["size"] >= 37
+            assert entries[1]["response"]["content"]["compression"] == 0
+
+            assert "encoding" not in entries[2]["response"]["content"]
+            assert entries[2]["response"]["content"]["mimeType"] == "image/png"
+            assert (
+                "a4c3a18f0bb83f5d9fe7ce561e065c36205762fa"
+                in entries[2]["response"]["content"]["_file"]
+            )
+            assert entries[2]["response"]["content"]["size"] >= 6000
+            assert entries[2]["response"]["content"]["compression"] == 0
+
+            with z.open("75841480e2606c03389077304342fac2c58ccb1b.html") as f:
+                assert b"HAR Page" in f.read()
 
+            with z.open("79f739d7bc88e80f55b9891a22bf13a2b4e18adb.css") as f:
+                assert b"pink" in f.read()
 
-async def test_should_include_content(browser, server, tmpdir):
-    path = os.path.join(tmpdir, "log.har")
+            with z.open("a4c3a18f0bb83f5d9fe7ce561e065c36205762fa.png") as f:
+                assert len(f.read()) == entries[2]["response"]["content"]["size"]
+
+
+async def test_should_not_omit_content(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
+    context = await browser.new_context(
+        record_har_path=path, record_har_omit_content=False
+    )
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/har.html")
+    await context.close()
+    with open(path) as f:
+        data = json.load(f)
+        content1 = data["log"]["entries"][0]["response"]["content"]
+        assert "text" in content1
+
+
+async def test_should_include_content(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = await browser.new_context(record_har_path=path)
     page = await context.new_page()
     await page.goto(server.PREFIX + "/har.html")
@@ -57,7 +166,641 @@ async def test_should_include_content(browser, server, tmpdir):
         log = data["log"]
 
         content1 = log["entries"][0]["response"]["content"]
-        assert content1["encoding"] == "base64"
-        assert content1["mimeType"] == "text/html"
-        s = base64.b64decode(content1["text"]).decode()
-        assert "HAR Page" in s
+        assert content1["mimeType"] == "text/html; charset=utf-8"
+        assert "HAR Page" in content1["text"]
+
+
+async def test_should_default_to_full_mode(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
+    context = await browser.new_context(
+        record_har_path=path,
+    )
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/har.html")
+    await context.close()
+    with open(path) as f:
+        data = json.load(f)
+        assert "log" in data
+        log = data["log"]
+        assert log["entries"][0]["request"]["bodySize"] >= 0
+
+
+async def test_should_support_minimal_mode(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
+    context = await browser.new_context(
+        record_har_path=path,
+        record_har_mode="minimal",
+    )
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/har.html")
+    await context.close()
+    with open(path) as f:
+        data = json.load(f)
+        assert "log" in data
+        log = data["log"]
+        assert log["entries"][0]["request"]["bodySize"] == -1
+
+
+async def test_should_filter_by_glob(
+    browser: Browser, server: Server, tmp_path: str
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
+    context = await browser.new_context(
+        base_url=server.PREFIX,
+        record_har_path=path,
+        record_har_url_filter="/*.css",
+        ignore_https_errors=True,
+    )
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/har.html")
+    await context.close()
+    with open(path) as f:
+        data = json.load(f)
+        assert "log" in data
+        log = data["log"]
+        assert len(log["entries"]) == 1
+        assert log["entries"][0]["request"]["url"].endswith("one-style.css")
+
+
+async def test_should_filter_by_regexp(
+    browser: Browser, server: Server, tmp_path: str
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
+    context = await browser.new_context(
+        base_url=server.PREFIX,
+        record_har_path=path,
+        record_har_url_filter=re.compile("HAR.X?HTML", re.I),
+        ignore_https_errors=True,
+    )
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/har.html")
+    await context.close()
+    with open(path) as f:
+        data = json.load(f)
+        assert "log" in data
+        log = data["log"]
+        assert len(log["entries"]) == 1
+        assert log["entries"][0]["request"]["url"].endswith("har.html")
+
+
+async def test_should_context_route_from_har_matching_the_method_and_following_redirects(
+    context: BrowserContext, assetdir: Path
+) -> None:
+    await context.route_from_har(har=assetdir / "har-fulfill.har")
+    page = await context.new_page()
+    await page.goto("http://no.playwright/")
+    # HAR contains a redirect for the script that should be followed automatically.
+    assert await page.evaluate("window.value") == "foo"
+    # HAR contains a POST for the css file that should not be used.
+    await expect(page.locator("body")).to_have_css("background-color", "rgb(255, 0, 0)")
+
+
+async def test_should_page_route_from_har_matching_the_method_and_following_redirects(
+    page: Page, assetdir: Path
+) -> None:
+    await page.route_from_har(har=assetdir / "har-fulfill.har")
+    await page.goto("http://no.playwright/")
+    # HAR contains a redirect for the script that should be followed automatically.
+    assert await page.evaluate("window.value") == "foo"
+    # HAR contains a POST for the css file that should not be used.
+    await expect(page.locator("body")).to_have_css("background-color", "rgb(255, 0, 0)")
+
+
+async def test_fallback_continue_should_continue_when_not_found_in_har(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    await context.route_from_har(har=assetdir / "har-fulfill.har", not_found="fallback")
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/one-style.html")
+    await expect(page.locator("body")).to_have_css(
+        "background-color", "rgb(255, 192, 203)"
+    )
+
+
+async def test_by_default_should_abort_requests_not_found_in_har(
+    context: BrowserContext,
+    server: Server,
+    assetdir: Path,
+    is_chromium: bool,
+    is_webkit: bool,
+) -> None:
+    await context.route_from_har(har=assetdir / "har-fulfill.har")
+    page = await context.new_page()
+
+    with pytest.raises(Error) as exc_info:
+        await page.goto(server.EMPTY_PAGE)
+    assert exc_info.value
+    if is_chromium:
+        assert "net::ERR_FAILED" in exc_info.value.message
+    elif is_webkit:
+        assert "Blocked by Web Inspector" in exc_info.value.message
+    else:
+        assert "NS_ERROR_FAILURE" in exc_info.value.message
+
+
+async def test_fallback_continue_should_continue_requests_on_bad_har(
+    context: BrowserContext, server: Server, tmp_path: Path
+) -> None:
+    path_to_invalid_har = tmp_path / "invalid.har"
+    with path_to_invalid_har.open("w") as f:
+        json.dump({"log": {}}, f)
+    await context.route_from_har(har=path_to_invalid_har, not_found="fallback")
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/one-style.html")
+    await expect(page.locator("body")).to_have_css(
+        "background-color", "rgb(255, 192, 203)"
+    )
+
+
+async def test_should_only_handle_requests_matching_url_filter(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    await context.route_from_har(
+        har=assetdir / "har-fulfill.har", not_found="fallback", url="**/*.js"
+    )
+    page = await context.new_page()
+
+    async def handler(route: Route) -> None:
+        assert route.request.url == "http://no.playwright/"
+        await route.fulfill(
+            status=200,
+            content_type="text/html",
+            body='<script src="./script.js"></script><div>hello</div>',
+        )
+
+    await context.route("http://no.playwright/", handler)
+    await page.goto("http://no.playwright/")
+    assert await page.evaluate("window.value") == "foo"
+    await expect(page.locator("body")).to_have_css(
+        "background-color", "rgba(0, 0, 0, 0)"
+    )
+
+
+async def test_should_only_handle_requests_matching_url_filter_no_fallback(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    await context.route_from_har(har=assetdir / "har-fulfill.har", url="**/*.js")
+    page = await context.new_page()
+
+    async def handler(route: Route) -> None:
+        assert route.request.url == "http://no.playwright/"
+        await route.fulfill(
+            status=200,
+            content_type="text/html",
+            body='<script src="./script.js"></script><div>hello</div>',
+        )
+
+    await context.route("http://no.playwright/", handler)
+    await page.goto("http://no.playwright/")
+    assert await page.evaluate("window.value") == "foo"
+    await expect(page.locator("body")).to_have_css(
+        "background-color", "rgba(0, 0, 0, 0)"
+    )
+
+
+async def test_should_only_handle_requests_matching_url_filter_no_fallback_page(
+    page: Page, server: Server, assetdir: Path
+) -> None:
+    await page.route_from_har(har=assetdir / "har-fulfill.har", url="**/*.js")
+
+    async def handler(route: Route) -> None:
+        assert route.request.url == "http://no.playwright/"
+        await route.fulfill(
+            status=200,
+            content_type="text/html",
+            body='<script src="./script.js"></script><div>hello</div>',
+        )
+
+    await page.route("http://no.playwright/", handler)
+    await page.goto("http://no.playwright/")
+    assert await page.evaluate("window.value") == "foo"
+    await expect(page.locator("body")).to_have_css(
+        "background-color", "rgba(0, 0, 0, 0)"
+    )
+
+
+async def test_should_support_regex_filter(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    await context.route_from_har(
+        har=assetdir / "har-fulfill.har",
+        url=re.compile(r".*(\.js|.*\.css|no.playwright\/)"),
+    )
+    page = await context.new_page()
+    await page.goto("http://no.playwright/")
+    assert await page.evaluate("window.value") == "foo"
+    await expect(page.locator("body")).to_have_css("background-color", "rgb(255, 0, 0)")
+
+
+async def test_should_change_document_url_after_redirected_navigation(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    await context.route_from_har(har=assetdir / "har-redirect.har")
+    page = await context.new_page()
+
+    async with page.expect_navigation() as navigation_info:
+        await asyncio.gather(
+            page.wait_for_url("https://www.theverge.com/"),
+            page.goto("https://theverge.com/"),
+        )
+
+    response = await navigation_info.value
+    await expect(page).to_have_url("https://www.theverge.com/")
+    assert response.request.url == "https://www.theverge.com/"
+    assert await page.evaluate("window.location.href") == "https://www.theverge.com/"
+
+
+async def test_should_change_document_url_after_redirected_navigation_on_click(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    await context.route_from_har(
+        har=assetdir / "har-redirect.har", url=re.compile(r"/.*theverge.*/")
+    )
+    page = await context.new_page()
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content('<a href="https://theverge.com/">click me</a>')
+    async with page.expect_navigation() as navigation_info:
+        await asyncio.gather(
+            page.wait_for_url("https://www.theverge.com/"),
+            page.click("text=click me"),
+        )
+
+    response = await navigation_info.value
+    await expect(page).to_have_url("https://www.theverge.com/")
+    assert response.request.url == "https://www.theverge.com/"
+    assert await page.evaluate("window.location.href") == "https://www.theverge.com/"
+
+
+async def test_should_go_back_to_redirected_navigation(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    await context.route_from_har(
+        har=assetdir / "har-redirect.har", url=re.compile(r"/.*theverge.*/")
+    )
+    page = await context.new_page()
+    await page.goto("https://theverge.com/")
+    await page.goto(server.EMPTY_PAGE)
+    await expect(page).to_have_url(server.EMPTY_PAGE)
+
+    response = await page.go_back()
+    assert response
+    await expect(page).to_have_url("https://www.theverge.com/")
+    assert response.request.url == "https://www.theverge.com/"
+    assert await page.evaluate("window.location.href") == "https://www.theverge.com/"
+
+
+async def test_should_go_forward_to_redirected_navigation(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    await context.route_from_har(
+        har=assetdir / "har-redirect.har", url=re.compile(r"/.*theverge.*/")
+    )
+    page = await context.new_page()
+    await page.goto("https://theverge.com/")
+    await page.goto(server.EMPTY_PAGE)
+    await expect(page).to_have_url(server.EMPTY_PAGE)
+    await page.goto("https://theverge.com/")
+    await expect(page).to_have_url("https://www.theverge.com/")
+    await page.go_back()
+    await expect(page).to_have_url(server.EMPTY_PAGE)
+    response = await page.go_forward()
+    assert response
+    await expect(page).to_have_url("https://www.theverge.com/")
+    assert response.request.url == "https://www.theverge.com/"
+    assert await page.evaluate("window.location.href") == "https://www.theverge.com/"
+
+
+async def test_should_reload_redirected_navigation(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    await context.route_from_har(
+        har=assetdir / "har-redirect.har", url=re.compile(r"/.*theverge.*/")
+    )
+    page = await context.new_page()
+    await page.goto("https://theverge.com/")
+    await expect(page).to_have_url("https://www.theverge.com/")
+    response = await page.reload()
+    assert response
+    await expect(page).to_have_url("https://www.theverge.com/")
+    assert response.request.url == "https://www.theverge.com/"
+    assert await page.evaluate("window.location.href") == "https://www.theverge.com/"
+
+
+async def test_should_fulfill_from_har_with_content_in_a_file(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    await context.route_from_har(har=assetdir / "har-sha1.har")
+    page = await context.new_page()
+    await page.goto("http://no.playwright/")
+    assert await page.content() == "<html><head></head><body>Hello, world</body></html>"
+
+
+async def test_should_round_trip_har_zip(
+    browser: Browser, server: Server, assetdir: Path, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.zip"
+    context_1 = await browser.new_context(
+        record_har_mode="minimal", record_har_path=har_path
+    )
+    page_1 = await context_1.new_page()
+    await page_1.goto(server.PREFIX + "/one-style.html")
+    await context_1.close()
+
+    context_2 = await browser.new_context()
+    await context_2.route_from_har(har=har_path, not_found="abort")
+    page_2 = await context_2.new_page()
+    await page_2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in await page_2.content()
+    await expect(page_2.locator("body")).to_have_css(
+        "background-color", "rgb(255, 192, 203)"
+    )
+
+
+async def test_should_round_trip_har_with_post_data(
+    browser: Browser, server: Server, assetdir: Path, tmp_path: Path
+) -> None:
+    server.set_route("/echo", lambda req: (req.write(req.post_body), req.finish()))
+    fetch_function = """
+        async (body) => {
+            const response = await fetch('/echo', { method: 'POST', body });
+            return await response.text();
+        };
+    """
+    har_path = tmp_path / "har.zip"
+    context_1 = await browser.new_context(
+        record_har_mode="minimal", record_har_path=har_path
+    )
+    page_1 = await context_1.new_page()
+    await page_1.goto(server.EMPTY_PAGE)
+
+    assert await page_1.evaluate(fetch_function, "1") == "1"
+    assert await page_1.evaluate(fetch_function, "2") == "2"
+    assert await page_1.evaluate(fetch_function, "3") == "3"
+    await context_1.close()
+
+    context_2 = await browser.new_context()
+    await context_2.route_from_har(har=har_path, not_found="abort")
+    page_2 = await context_2.new_page()
+    await page_2.goto(server.EMPTY_PAGE)
+    assert await page_2.evaluate(fetch_function, "1") == "1"
+    assert await page_2.evaluate(fetch_function, "2") == "2"
+    assert await page_2.evaluate(fetch_function, "3") == "3"
+    with pytest.raises(Exception):
+        await page_2.evaluate(fetch_function, "4")
+
+
+async def test_should_disambiguate_by_header(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    server.set_route(
+        "/echo",
+        lambda req: (req.write(cast(str, req.getHeader("baz")).encode()), req.finish()),
+    )
+    fetch_function = """
+        async (bazValue) => {
+            const response = await fetch('/echo', {
+            method: 'POST',
+            body: '',
+            headers: {
+                foo: 'foo-value',
+                bar: 'bar-value',
+                baz: bazValue,
+            }
+            });
+            return await response.text();
+        };
+    """
+    har_path = tmp_path / "har.zip"
+    context_1 = await browser.new_context(
+        record_har_mode="minimal", record_har_path=har_path
+    )
+    page_1 = await context_1.new_page()
+    await page_1.goto(server.EMPTY_PAGE)
+
+    assert await page_1.evaluate(fetch_function, "baz1") == "baz1"
+    assert await page_1.evaluate(fetch_function, "baz2") == "baz2"
+    assert await page_1.evaluate(fetch_function, "baz3") == "baz3"
+    await context_1.close()
+
+    context_2 = await browser.new_context()
+    await context_2.route_from_har(har=har_path)
+    page_2 = await context_2.new_page()
+    await page_2.goto(server.EMPTY_PAGE)
+    assert await page_2.evaluate(fetch_function, "baz1") == "baz1"
+    assert await page_2.evaluate(fetch_function, "baz2") == "baz2"
+    assert await page_2.evaluate(fetch_function, "baz3") == "baz3"
+    assert await page_2.evaluate(fetch_function, "baz4") == "baz1"
+
+
+async def test_should_produce_extracted_zip(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.har"
+    context = await browser.new_context(
+        record_har_mode="minimal", record_har_path=har_path, record_har_content="attach"
+    )
+    page_1 = await context.new_page()
+    await page_1.goto(server.PREFIX + "/one-style.html")
+    await context.close()
+
+    assert har_path.exists()
+    with har_path.open() as r:
+        content = r.read()
+        assert "log" in content
+        assert "background-color" not in r.read()
+
+    context_2 = await browser.new_context()
+    await context_2.route_from_har(har_path, not_found="abort")
+    page_2 = await context_2.new_page()
+    await page_2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in await page_2.content()
+    await expect(page_2.locator("body")).to_have_css(
+        "background-color", "rgb(255, 192, 203)"
+    )
+
+
+async def test_should_update_har_zip_for_context(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.zip"
+    context = await browser.new_context()
+    await context.route_from_har(har_path, update=True)
+    page_1 = await context.new_page()
+    await page_1.goto(server.PREFIX + "/one-style.html")
+    await context.close()
+
+    assert har_path.exists()
+
+    context_2 = await browser.new_context()
+    await context_2.route_from_har(har_path, not_found="abort")
+    page_2 = await context_2.new_page()
+    await page_2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in await page_2.content()
+    await expect(page_2.locator("body")).to_have_css(
+        "background-color", "rgb(255, 192, 203)"
+    )
+
+
+async def test_page_unroute_all_should_stop_page_route_from_har(
+    context_factory: Callable[[], Awaitable[BrowserContext]],
+    server: Server,
+    assetdir: Path,
+) -> None:
+    har_path = assetdir / "har-fulfill.har"
+    context1 = await context_factory()
+    page1 = await context1.new_page()
+    # The har file contains requests for another domain, so the router
+    # is expected to abort all requests.
+    await page1.route_from_har(har_path, not_found="abort")
+    with pytest.raises(Error) as exc_info:
+        await page1.goto(server.EMPTY_PAGE)
+    assert exc_info.value
+    await page1.unroute_all(behavior="wait")
+    response = must(await page1.goto(server.EMPTY_PAGE))
+    assert response.ok
+
+
+async def test_context_unroute_call_should_stop_context_route_from_har(
+    context_factory: Callable[[], Awaitable[BrowserContext]],
+    server: Server,
+    assetdir: Path,
+) -> None:
+    har_path = assetdir / "har-fulfill.har"
+    context1 = await context_factory()
+    page1 = await context1.new_page()
+    # The har file contains requests for another domain, so the router
+    # is expected to abort all requests.
+    await context1.route_from_har(har_path, not_found="abort")
+    with pytest.raises(Error) as exc_info:
+        await page1.goto(server.EMPTY_PAGE)
+    assert exc_info.value
+    await context1.unroute_all(behavior="wait")
+    response = must(await page1.goto(server.EMPTY_PAGE))
+    assert must(response).ok
+
+
+async def test_should_update_har_zip_for_page(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.zip"
+    context = await browser.new_context()
+    page_1 = await context.new_page()
+    await page_1.route_from_har(har_path, update=True)
+    await page_1.goto(server.PREFIX + "/one-style.html")
+    await context.close()
+
+    assert har_path.exists()
+
+    context_2 = await browser.new_context()
+    page_2 = await context_2.new_page()
+    await page_2.route_from_har(har_path, not_found="abort")
+    await page_2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in await page_2.content()
+    await expect(page_2.locator("body")).to_have_css(
+        "background-color", "rgb(255, 192, 203)"
+    )
+
+
+async def test_should_update_har_zip_for_page_with_different_options(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.zip"
+    context1 = await browser.new_context()
+    page1 = await context1.new_page()
+    await page1.route_from_har(
+        har_path, update=True, update_content="embed", update_mode="full"
+    )
+    await page1.goto(server.PREFIX + "/one-style.html")
+    await context1.close()
+
+    context2 = await browser.new_context()
+    page2 = await context2.new_page()
+    await page2.route_from_har(har_path, not_found="abort")
+    await page2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in await page2.content()
+    await expect(page2.locator("body")).to_have_css(
+        "background-color", "rgb(255, 192, 203)"
+    )
+    await context2.close()
+
+
+async def test_should_update_extracted_har_zip_for_page(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.har"
+    context = await browser.new_context()
+    page_1 = await context.new_page()
+    await page_1.route_from_har(har_path, update=True)
+    await page_1.goto(server.PREFIX + "/one-style.html")
+    await context.close()
+
+    assert har_path.exists()
+    with har_path.open() as r:
+        content = r.read()
+        assert "log" in content
+        assert "background-color" not in r.read()
+
+    context_2 = await browser.new_context()
+    page_2 = await context_2.new_page()
+    await page_2.route_from_har(har_path, not_found="abort")
+    await page_2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in await page_2.content()
+    await expect(page_2.locator("body")).to_have_css(
+        "background-color", "rgb(255, 192, 203)"
+    )
+
+
+async def test_should_ignore_aborted_requests(
+    context_factory: Callable[[], Awaitable[BrowserContext]],
+    server: Server,
+    tmp_path: Path,
+) -> None:
+    path = tmp_path / "test.har"
+    server.set_route("/x", lambda request: request.loseConnection())
+    context1 = await context_factory()
+    await context1.route_from_har(har=path, update=True)
+    page1 = await context1.new_page()
+    await page1.goto(server.EMPTY_PAGE)
+    req_promise = asyncio.create_task(server.wait_for_request("/x"))
+    eval_task = asyncio.create_task(
+        page1.evaluate(
+            "url => fetch(url).catch(e => 'cancelled')", server.PREFIX + "/x"
+        )
+    )
+    await req_promise
+    req = await eval_task
+    assert req == "cancelled"
+    await context1.close()
+
+    server.reset()
+
+    def _handle_route(req: TestServerRequest) -> None:
+        req.setHeader("Content-Type", "text/plain")
+        req.write(b"test")
+        req.finish()
+
+    server.set_route("/x", _handle_route)
+    context2 = await context_factory()
+    await context2.route_from_har(path)
+    page2 = await context2.new_page()
+    await page2.goto(server.EMPTY_PAGE)
+    eval_task = asyncio.create_task(
+        page2.evaluate(
+            "url => fetch(url).catch(e => 'cancelled')", server.PREFIX + "/x"
+        )
+    )
+
+    async def _timeout() -> str:
+        await asyncio.sleep(1)
+        return "timeout"
+
+    done, _ = await asyncio.wait(
+        [eval_task, asyncio.create_task(_timeout())],
+        return_when=asyncio.FIRST_COMPLETED,
+    )
+    assert next(iter(done)).result() == "timeout"
+    eval_task.cancel()
diff --git a/tests/async/test_headful.py b/tests/async/test_headful.py
index 3d09d3fe6..2b0b64c8e 100644
--- a/tests/async/test_headful.py
+++ b/tests/async/test_headful.py
@@ -1,10 +1,10 @@
 # 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
 #
-# http:#www.apache.org/licenses/LICENSE-2.0
+# 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,
@@ -13,56 +13,31 @@
 # limitations under the License.
 
 
-import asyncio
+from pathlib import Path
+from typing import Dict
 
 import pytest
-from flaky import flaky
+
+from playwright.async_api import BrowserType
+from tests.server import Server
 
 
 async def test_should_have_default_url_when_launching_browser(
-    browser_type, launch_arguments, tmpdir
-):
+    browser_type: BrowserType, launch_arguments: Dict, tmp_path: Path
+) -> None:
     browser_context = await browser_type.launch_persistent_context(
-        tmpdir, **{**launch_arguments, "headless": False}
+        tmp_path, **{**launch_arguments, "headless": False}
     )
     urls = [page.url for page in browser_context.pages]
     assert urls == ["about:blank"]
     await browser_context.close()
 
 
-async def test_headless_should_be_able_to_read_cookies_written_by_headful(
-    browser_type, launch_arguments, server, tmpdir, is_chromium, is_win
-):
-    if is_chromium and is_win:
-        pytest.skip("see https://github.com/microsoft/playwright/issues/717")
-        return
-    # Write a cookie in headful chrome
-    headful_context = await browser_type.launch_persistent_context(
-        tmpdir, **{**launch_arguments, "headless": False}
-    )
-    headful_page = await headful_context.new_page()
-    await headful_page.goto(server.EMPTY_PAGE)
-    await headful_page.evaluate(
-        """() => document.cookie = 'foo=true; expires=Fri, 31 Dec 9999 23:59:59 GMT'"""
-    )
-    await headful_context.close()
-    # Read the cookie from headless chrome
-    headless_context = await browser_type.launch_persistent_context(
-        tmpdir, **{**launch_arguments, "headless": True}
-    )
-    headless_page = await headless_context.new_page()
-    await headless_page.goto(server.EMPTY_PAGE)
-    cookie = await headless_page.evaluate("() => document.cookie")
-    await headless_context.close()
-    # This might throw. See https://github.com/GoogleChrome/puppeteer/issues/2778
-    assert cookie == "foo=true"
-
-
 async def test_should_close_browser_with_beforeunload_page(
-    browser_type, launch_arguments, server, tmpdir
-):
+    browser_type: BrowserType, launch_arguments: Dict, server: Server, tmp_path: Path
+) -> None:
     browser_context = await browser_type.launch_persistent_context(
-        tmpdir, **{**launch_arguments, "headless": False}
+        tmp_path, **{**launch_arguments, "headless": False}
     )
     page = await browser_context.new_page()
     await page.goto(server.PREFIX + "/beforeunload.html")
@@ -73,8 +48,8 @@ async def test_should_close_browser_with_beforeunload_page(
 
 
 async def test_should_not_crash_when_creating_second_context(
-    browser_type, launch_arguments, server
-):
+    browser_type: BrowserType, launch_arguments: Dict, server: Server
+) -> None:
     browser = await browser_type.launch(**{**launch_arguments, "headless": False})
     browser_context = await browser.new_context()
     await browser_context.new_page()
@@ -85,7 +60,9 @@ async def test_should_not_crash_when_creating_second_context(
     await browser.close()
 
 
-async def test_should_click_background_tab(browser_type, launch_arguments, server):
+async def test_should_click_background_tab(
+    browser_type: BrowserType, launch_arguments: Dict, server: Server
+) -> None:
     browser = await browser_type.launch(**{**launch_arguments, "headless": False})
     page = await browser.new_page()
     await page.set_content(
@@ -97,8 +74,8 @@ async def test_should_click_background_tab(browser_type, launch_arguments, serve
 
 
 async def test_should_close_browser_after_context_menu_was_triggered(
-    browser_type, launch_arguments, server
-):
+    browser_type: BrowserType, launch_arguments: Dict, server: Server
+) -> None:
     browser = await browser_type.launch(**{**launch_arguments, "headless": False})
     page = await browser.new_page()
     await page.goto(server.PREFIX + "/grid.html")
@@ -107,8 +84,12 @@ async def test_should_close_browser_after_context_menu_was_triggered(
 
 
 async def test_should_not_block_third_party_cookies(
-    browser_type, launch_arguments, server, is_chromium, is_firefox
-):
+    browser_type: BrowserType,
+    launch_arguments: Dict,
+    server: Server,
+    is_chromium: bool,
+    is_firefox: bool,
+) -> None:
     browser = await browser_type.launch(**{**launch_arguments, "headless": False})
     page = await browser.new_page()
     await page.goto(server.EMPTY_PAGE)
@@ -132,7 +113,7 @@ async def test_should_not_block_third_party_cookies(
     )
 
     await page.wait_for_timeout(2000)
-    allows_third_party = is_chromium or is_firefox
+    allows_third_party = is_firefox
     assert document_cookie == ("username=John Doe" if allows_third_party else "")
     cookies = await page.context.cookies(server.CROSS_PROCESS_PREFIX + "/grid.html")
     if allows_third_party:
@@ -143,7 +124,7 @@ async def test_should_not_block_third_party_cookies(
                 "httpOnly": False,
                 "name": "username",
                 "path": "/",
-                "sameSite": "None",
+                "sameSite": "Lax" if is_chromium else "None",
                 "secure": False,
                 "value": "John Doe",
             }
@@ -156,22 +137,21 @@ async def test_should_not_block_third_party_cookies(
 
 @pytest.mark.skip_browser("webkit")
 async def test_should_not_override_viewport_size_when_passed_null(
-    browser_type, launch_arguments, server
-):
+    browser_type: BrowserType, launch_arguments: Dict, server: Server
+) -> None:
     # Our WebKit embedder does not respect window features.
     browser = await browser_type.launch(**{**launch_arguments, "headless": False})
-    context = await browser.new_context(viewport=0)
+    context = await browser.new_context(no_viewport=True)
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
-    [popup, _] = await asyncio.gather(
-        page.wait_for_event("popup"),
-        page.evaluate(
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
             """() => {
-      const win = window.open(window.location.href, 'Title', 'toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,width=600,height=300,top=0,left=0');
-      win.resizeTo(500, 450);
-    }"""
-        ),
-    )
+                const win = window.open(window.location.href, 'Title', 'toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,width=600,height=300,top=0,left=0');
+                win.resizeTo(500, 450);
+            }"""
+        )
+    popup = await popup_info.value
     await popup.wait_for_load_state()
     await popup.wait_for_function(
         """() => window.outerWidth === 500 && window.outerHeight === 450"""
@@ -180,8 +160,9 @@ async def test_should_not_override_viewport_size_when_passed_null(
     await browser.close()
 
 
-@flaky
-async def test_page_bring_to_front_should_work(browser_type, launch_arguments):
+async def test_page_bring_to_front_should_work(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
     browser = await browser_type.launch(**{**launch_arguments, "headless": False})
     page1 = await browser.new_page()
     await page1.set_content("Page1")
diff --git a/tests/async/test_ignore_https_errors.py b/tests/async/test_ignore_https_errors.py
index e9092aa94..53a6eabb1 100644
--- a/tests/async/test_ignore_https_errors.py
+++ b/tests/async/test_ignore_https_errors.py
@@ -14,18 +14,24 @@
 
 import pytest
 
-from playwright.async_api import Error
+from playwright.async_api import Browser, Error
+from tests.server import Server
 
 
-async def test_ignore_https_error_should_work(browser, https_server):
+async def test_ignore_https_error_should_work(
+    browser: Browser, https_server: Server
+) -> None:
     context = await browser.new_context(ignore_https_errors=True)
     page = await context.new_page()
     response = await page.goto(https_server.EMPTY_PAGE)
+    assert response
     assert response.ok
     await context.close()
 
 
-async def test_ignore_https_error_should_work_negative_case(browser, https_server):
+async def test_ignore_https_error_should_work_negative_case(
+    browser: Browser, https_server: Server
+) -> None:
     context = await browser.new_context()
     page = await context.new_page()
     with pytest.raises(Error):
diff --git a/tests/async/test_input.py b/tests/async/test_input.py
index 735207858..b7bd3d799 100644
--- a/tests/async/test_input.py
+++ b/tests/async/test_input.py
@@ -14,18 +14,28 @@
 
 import asyncio
 import os
+import re
+import shutil
+import sys
+from pathlib import Path
+from typing import Any
+
+import pytest
 
 from playwright._impl._path_utils import get_file_dirname
-from playwright.async_api import FilePayload, Page
+from playwright.async_api import Error, FilePayload, Page
+from tests.server import Server
+from tests.utils import chromium_version_less_than, must
 
 _dirname = get_file_dirname()
 FILE_TO_UPLOAD = _dirname / ".." / "assets/file-to-upload.txt"
 
 
-async def test_should_upload_the_file(page, server):
+async def test_should_upload_the_file(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/fileupload.html")
     file_path = os.path.relpath(FILE_TO_UPLOAD, os.getcwd())
     input = await page.query_selector("input")
+    assert input
     await input.set_input_files(file_path)
     assert await page.evaluate("e => e.files[0].name", input) == "file-to-upload.txt"
     assert (
@@ -42,7 +52,7 @@ async def test_should_upload_the_file(page, server):
     )
 
 
-async def test_should_work(page, assetdir):
+async def test_should_work(page: Page, assetdir: Path) -> None:
     await page.set_content("<input type=file>")
     await page.set_input_files("input", assetdir / "file-to-upload.txt")
     assert await page.eval_on_selector("input", "input => input.files.length") == 1
@@ -52,11 +62,16 @@ async def test_should_work(page, assetdir):
     )
 
 
-async def test_should_set_from_memory(page):
+async def test_should_set_from_memory(page: Page) -> None:
     await page.set_content("<input type=file>")
+    file: FilePayload = {
+        "name": "test.txt",
+        "mimeType": "text/plain",
+        "buffer": b"this is a test",
+    }
     await page.set_input_files(
         "input",
-        files=[FilePayload("test.txt", "text/plain", b"this is a test")],
+        files=[file],
     )
     assert await page.eval_on_selector("input", "input => input.files.length") == 1
     assert (
@@ -65,40 +80,43 @@ async def test_should_set_from_memory(page):
     )
 
 
-async def test_should_emit_event(page: Page, server):
+async def test_should_emit_event(page: Page) -> None:
     await page.set_content("<input type=file>")
     fc_done: asyncio.Future = asyncio.Future()
     page.once("filechooser", lambda file_chooser: fc_done.set_result(file_chooser))
     await page.click("input")
     file_chooser = await fc_done
     assert file_chooser
+    assert (
+        repr(file_chooser)
+        == f"<FileChooser page={file_chooser.page} element={file_chooser.element}>"
+    )
 
 
-async def test_should_work_when_file_input_is_attached_to_DOM(page: Page, server):
+async def test_should_work_when_file_input_is_attached_to_dom(page: Page) -> None:
     await page.set_content("<input type=file>")
-    async with page.expect_event("filechooser") as fc_info:
+    async with page.expect_file_chooser() as fc_info:
         await page.click("input")
     file_chooser = await fc_info.value
     assert file_chooser
 
 
-async def test_should_work_when_file_input_is_not_attached_to_DOM(page, server):
-    [file_chooser, _] = await asyncio.gather(
-        page.wait_for_event("filechooser"),
-        page.evaluate(
+async def test_should_work_when_file_input_is_not_attached_to_DOM(page: Page) -> None:
+    async with page.expect_file_chooser() as fc_info:
+        await page.evaluate(
             """() => {
-        el = document.createElement('input')
-        el.type = 'file'
-        el.click()
-      }"""
-        ),
-    )
+                el = document.createElement('input')
+                el.type = 'file'
+                el.click()
+            }"""
+        )
+    file_chooser = await fc_info.value
     assert file_chooser
 
 
 async def test_should_return_the_same_file_chooser_when_there_are_many_watchdogs_simultaneously(
-    page: Page, server
-):
+    page: Page,
+) -> None:
     await page.set_content("<input type=file>")
     results = await asyncio.gather(
         page.wait_for_event("filechooser"),
@@ -108,14 +126,11 @@ async def test_should_return_the_same_file_chooser_when_there_are_many_watchdogs
     assert results[0] == results[1]
 
 
-async def test_should_accept_single_file(page: Page, server):
+async def test_should_accept_single_file(page: Page) -> None:
     await page.set_content('<input type=file oninput="javascript:console.timeStamp()">')
-    file_chooser = (
-        await asyncio.gather(
-            page.wait_for_event("filechooser"),
-            page.click("input"),
-        )
-    )[0]
+    async with page.expect_file_chooser() as fc_info:
+        await page.click("input")
+    file_chooser = await fc_info.value
     assert file_chooser.page == page
     assert file_chooser.element
     await file_chooser.set_files(FILE_TO_UPLOAD)
@@ -126,12 +141,9 @@ async def test_should_accept_single_file(page: Page, server):
     )
 
 
-async def test_should_be_able_to_read_selected_file(page: Page, server):
+async def test_should_be_able_to_read_selected_file(page: Page) -> None:
     page.once(
-        "filechooser",
-        lambda file_chooser: asyncio.create_task(
-            file_chooser.set_files(FILE_TO_UPLOAD)
-        ),
+        "filechooser", lambda file_chooser: file_chooser.set_files(FILE_TO_UPLOAD)
     )
     await page.set_content("<input type=file>")
     content = await page.eval_on_selector(
@@ -149,74 +161,55 @@ async def test_should_be_able_to_read_selected_file(page: Page, server):
 
 
 async def test_should_be_able_to_reset_selected_files_with_empty_file_list(
-    page: Page, server
-):
+    page: Page,
+) -> None:
     await page.set_content("<input type=file>")
     page.once(
-        "filechooser",
-        lambda file_chooser: asyncio.create_task(
-            file_chooser.set_files(FILE_TO_UPLOAD)
-        ),
+        "filechooser", lambda file_chooser: file_chooser.set_files(FILE_TO_UPLOAD)
     )
-    file_length_1 = (
-        await asyncio.gather(
-            page.wait_for_event("filechooser"),
-            page.eval_on_selector(
-                "input",
-                """async picker => {
-                    picker.click();
-                    await new Promise(x => picker.oninput = x);
-                    return picker.files.length;
-                }""",
-            ),
+    file_length = 0
+    async with page.expect_file_chooser():
+        file_length = await page.eval_on_selector(
+            "input",
+            """async picker => {
+                picker.click();
+                await new Promise(x => picker.oninput = x);
+                return picker.files.length;
+            }""",
         )
-    )[1]
-    assert file_length_1 == 1
-
-    page.once(
-        "filechooser",
-        lambda file_chooser: asyncio.create_task(file_chooser.set_files([])),
-    )
-    file_length_2 = (
-        await asyncio.gather(
-            page.wait_for_event("filechooser"),
-            page.eval_on_selector(
-                "input",
-                """async picker => {
-                    picker.click()
-                    await new Promise(x => picker.oninput = x)
-                    return picker.files.length
-                }""",
-            ),
+    assert file_length == 1
+
+    page.once("filechooser", lambda file_chooser: file_chooser.set_files([]))
+    async with page.expect_file_chooser():
+        file_length = await page.eval_on_selector(
+            "input",
+            """async picker => {
+                picker.click();
+                await new Promise(x => picker.oninput = x);
+                return picker.files.length;
+            }""",
         )
-    )[1]
-    assert file_length_2 == 0
+    assert file_length == 0
 
 
 async def test_should_not_accept_multiple_files_for_single_file_input(
-    page, server, assetdir
-):
+    page: Page, assetdir: Path
+) -> None:
     await page.set_content("<input type=file>")
-    file_chooser = (
-        await asyncio.gather(
-            page.wait_for_event("filechooser"),
-            page.click("input"),
-        )
-    )[0]
-    error = None
-    try:
+    async with page.expect_file_chooser() as fc_info:
+        await page.click("input")
+    file_chooser = await fc_info.value
+    with pytest.raises(Exception) as exc_info:
         await file_chooser.set_files(
             [
                 os.path.realpath(assetdir / "file-to-upload.txt"),
                 os.path.realpath(assetdir / "pptr.png"),
             ]
         )
-    except Exception as exc:
-        error = exc
-    assert error is not None
+    assert exc_info.value
 
 
-async def test_should_emit_input_and_change_events(page, server):
+async def test_should_emit_input_and_change_events(page: Page) -> None:
     events = []
     await page.expose_function("eventHandled", lambda e: events.append(e))
     await page.set_content(
@@ -228,40 +221,289 @@ async def test_should_emit_input_and_change_events(page, server):
             </script>
         """
     )
-    await (await page.query_selector("input")).set_input_files(FILE_TO_UPLOAD)
+    await must(await page.query_selector("input")).set_input_files(FILE_TO_UPLOAD)
     assert len(events) == 2
     assert events[0]["type"] == "input"
     assert events[1]["type"] == "change"
 
 
-async def test_should_work_for_single_file_pick(page, server):
+async def test_should_work_for_single_file_pick(page: Page) -> None:
     await page.set_content("<input type=file>")
-    file_chooser = (
-        await asyncio.gather(
-            page.wait_for_event("filechooser"),
-            page.click("input"),
-        )
-    )[0]
-    assert file_chooser.is_multiple is False
+    async with page.expect_file_chooser() as fc_info:
+        await page.click("input")
+    file_chooser = await fc_info.value
+    assert file_chooser.is_multiple() is False
 
 
-async def test_should_work_for_multiple(page, server):
+async def test_should_work_for_multiple(page: Page) -> None:
     await page.set_content("<input multiple type=file>")
-    file_chooser = (
-        await asyncio.gather(
-            page.wait_for_event("filechooser"),
-            page.click("input"),
-        )
-    )[0]
-    assert file_chooser.is_multiple
+    async with page.expect_file_chooser() as fc_info:
+        await page.click("input")
+    file_chooser = await fc_info.value
+    assert file_chooser.is_multiple()
 
 
-async def test_should_work_for_webkitdirectory(page, server):
+async def test_should_work_for_webkitdirectory(page: Page) -> None:
     await page.set_content("<input multiple webkitdirectory type=file>")
-    file_chooser = (
-        await asyncio.gather(
-            page.wait_for_event("filechooser"),
-            page.click("input"),
+    async with page.expect_file_chooser() as fc_info:
+        await page.click("input")
+    file_chooser = await fc_info.value
+    assert file_chooser.is_multiple()
+
+
+def _assert_wheel_event(expected: Any, received: Any, browser_name: str) -> None:
+    # Chromium reports deltaX/deltaY scaled by host device scale factor.
+    # https://bugs.chromium.org/p/chromium/issues/detail?id=1324819
+    # https://github.com/microsoft/playwright/issues/7362
+    # Different bots have different scale factors (usually 1 or 2), so we just ignore the values
+    # instead of guessing the host scale factor.
+    if sys.platform == "darwin" and browser_name == "chromium":
+        del expected["deltaX"]
+        del expected["deltaY"]
+        del received["deltaX"]
+        del received["deltaY"]
+    assert received == expected
+
+
+async def test_wheel_should_work(page: Page, browser_name: str) -> None:
+    await page.set_content(
+        """
+        <div style="width: 5000px; height: 5000px;"></div>
+    """
+    )
+    await page.mouse.move(50, 60)
+    await _listen_for_wheel_events(page, "div")
+    await page.mouse.wheel(0, 100)
+    _assert_wheel_event(
+        await page.evaluate("window.lastEvent"),
+        {
+            "deltaX": 0,
+            "deltaY": 100,
+            "clientX": 50,
+            "clientY": 60,
+            "deltaMode": 0,
+            "ctrlKey": False,
+            "shiftKey": False,
+            "altKey": False,
+            "metaKey": False,
+        },
+        browser_name,
+    )
+    await page.wait_for_function("window.scrollY === 100")
+
+
+async def _listen_for_wheel_events(page: Page, selector: str) -> None:
+    await page.evaluate(
+        """
+        selector => {
+            document.querySelector(selector).addEventListener('wheel', (e) => {
+            window['lastEvent'] = {
+                deltaX: e.deltaX,
+                deltaY: e.deltaY,
+                clientX: e.clientX,
+                clientY: e.clientY,
+                deltaMode: e.deltaMode,
+                ctrlKey: e.ctrlKey,
+                shiftKey: e.shiftKey,
+                altKey: e.altKey,
+                metaKey: e.metaKey,
+            };
+            }, { passive: false });
+        }
+    """,
+        selector,
+    )
+
+
+async def test_should_upload_large_file(
+    page: Page, server: Server, tmp_path: Path
+) -> None:
+    await page.goto(server.PREFIX + "/input/fileupload.html")
+    large_file_path = tmp_path / "200MB.zip"
+    data = b"A" * 1024
+    with large_file_path.open("wb") as f:
+        for i in range(0, 200 * 1024 * 1024, len(data)):
+            f.write(data)
+    input = page.locator('input[type="file"]')
+    events = await input.evaluate_handle(
+        """
+        e => {
+            const events = [];
+            e.addEventListener('input', () => events.push('input'));
+            e.addEventListener('change', () => events.push('change'));
+            return events;
+        }
+    """
+    )
+
+    await input.set_input_files(large_file_path)
+    assert await input.evaluate("e => e.files[0].name") == "200MB.zip"
+    assert await events.evaluate("e => e") == ["input", "change"]
+
+    [request, _] = await asyncio.gather(
+        server.wait_for_request("/upload"),
+        page.click("input[type=submit]"),
+    )
+
+    contents = request.args[b"file1"][0]
+    assert len(contents) == 200 * 1024 * 1024
+    assert contents[:1024] == data
+    # flake8: noqa: E203
+    assert contents[len(contents) - 1024 :] == data
+    assert request.post_body
+    match = re.search(
+        rb'^.*Content-Disposition: form-data; name="(?P<name>.*)"; filename="(?P<filename>.*)".*$',
+        request.post_body,
+        re.MULTILINE,
+    )
+    assert match
+    assert match.group("name") == b"file1"
+    assert match.group("filename") == b"200MB.zip"
+
+
+async def test_set_input_files_should_preserve_last_modified_timestamp(
+    page: Page,
+    assetdir: Path,
+) -> None:
+    await page.set_content("<input type=file multiple=true/>")
+    input = page.locator("input")
+    files = ["file-to-upload.txt", "file-to-upload-2.txt"]
+    await input.set_input_files([assetdir / file for file in files])
+    assert await input.evaluate("input => [...input.files].map(f => f.name)") == files
+    timestamps = await input.evaluate(
+        "input => [...input.files].map(f => f.lastModified)"
+    )
+    expected_timestamps = [os.path.getmtime(assetdir / file) * 1000 for file in files]
+
+    # On Linux browser sometimes reduces the timestamp by 1ms: 1696272058110.0715  -> 1696272058109 or even
+    # rounds it to seconds in WebKit: 1696272058110 -> 1696272058000.
+    for i in range(len(timestamps)):
+        assert abs(timestamps[i] - expected_timestamps[i]) < 1000
+
+
+async def test_should_upload_multiple_large_file(
+    page: Page, server: Server, tmp_path: Path
+) -> None:
+    files_count = 10
+    await page.goto(server.PREFIX + "/input/fileupload-multi.html")
+    upload_file = tmp_path / "50MB_1.zip"
+    data = b"A" * 1024
+    with upload_file.open("wb") as f:
+        # 49 is close to the actual limit
+        for i in range(0, 49 * 1024):
+            f.write(data)
+    input = page.locator('input[type="file"]')
+    upload_files = [upload_file]
+    for i in range(2, files_count + 1):
+        dst_file = tmp_path / f"50MB_{i}.zip"
+        shutil.copy(upload_file, dst_file)
+        upload_files.append(dst_file)
+    async with page.expect_file_chooser() as fc_info:
+        await input.click()
+    file_chooser = await fc_info.value
+    await file_chooser.set_files(upload_files)
+    files_len = await page.evaluate(
+        'document.getElementsByTagName("input")[0].files.length'
+    )
+    assert file_chooser.is_multiple()
+    assert files_len == files_count
+    for path in upload_files:
+        path.unlink()
+
+
+async def test_should_upload_a_folder(
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    browser_name: str,
+    browser_version: str,
+    headless: bool,
+) -> None:
+    await page.goto(server.PREFIX + "/input/folderupload.html")
+    input = await page.query_selector("input")
+    assert input
+    dir = tmp_path / "file-upload-test"
+    dir.mkdir()
+    (dir / "file1.txt").write_text("file1 content")
+    (dir / "file2").write_text("file2 content")
+    (dir / "sub-dir").mkdir()
+    (dir / "sub-dir" / "really.txt").write_text("sub-dir file content")
+    await input.set_input_files(dir)
+    assert set(
+        await input.evaluate("e => [...e.files].map(f => f.webkitRelativePath)")
+    ) == set(
+        [
+            "file-upload-test/file1.txt",
+            "file-upload-test/file2",
+            # https://issues.chromium.org/issues/345393164
+            *(
+                []
+                if browser_name == "chromium"
+                and headless
+                and chromium_version_less_than(browser_version, "127.0.6533.0")
+                else ["file-upload-test/sub-dir/really.txt"]
+            ),
+        ]
+    )
+    webkit_relative_paths = await input.evaluate(
+        "e => [...e.files].map(f => f.webkitRelativePath)"
+    )
+    for i, webkit_relative_path in enumerate(webkit_relative_paths):
+        content = await input.evaluate(
+            """(e, i) => {
+            const reader = new FileReader();
+            const promise = new Promise(fulfill => reader.onload = fulfill);
+            reader.readAsText(e.files[i]);
+            return promise.then(() => reader.result);
+        }""",
+            i,
         )
-    )[0]
-    assert file_chooser.is_multiple
+        assert content == (dir / ".." / webkit_relative_path).read_text()
+
+
+async def test_should_upload_a_folder_and_throw_for_multiple_directories(
+    page: Page, server: Server, tmp_path: Path
+) -> None:
+    await page.goto(server.PREFIX + "/input/folderupload.html")
+    input = page.locator("input")
+    dir = tmp_path / "file-upload-test"
+    dir.mkdir()
+    (dir / "folder1").mkdir()
+    (dir / "folder1" / "file1.txt").write_text("file1 content")
+    (dir / "folder2").mkdir()
+    (dir / "folder2" / "file2.txt").write_text("file2 content")
+    with pytest.raises(Error) as exc_info:
+        await input.set_input_files([dir / "folder1", dir / "folder2"])
+    assert "Multiple directories are not supported" in exc_info.value.message
+
+
+async def test_should_throw_if_a_directory_and_files_are_passed(
+    page: Page, server: Server, tmp_path: Path
+) -> None:
+    await page.goto(server.PREFIX + "/input/folderupload.html")
+    input = page.locator("input")
+    dir = tmp_path / "file-upload-test"
+    dir.mkdir()
+    (dir / "file1.txt").write_text("file1 content")
+    with pytest.raises(Error) as exc_info:
+        await input.set_input_files([dir, dir / "file1.txt"])
+    assert (
+        "File paths must be all files or a single directory" in exc_info.value.message
+    )
+
+
+async def test_should_throw_when_upload_a_folder_in_a_normal_file_upload_input(
+    page: Page, server: Server, tmp_path: Path
+) -> None:
+    await page.goto(server.PREFIX + "/input/fileupload.html")
+    input = await page.query_selector("input")
+    assert input
+    dir = tmp_path / "file-upload-test"
+    dir.mkdir()
+    (dir / "file1.txt").write_text("file1 content")
+    with pytest.raises(Error) as exc_info:
+        await input.set_input_files(dir)
+    assert (
+        "File input does not support directories, pass individual files instead"
+        in exc_info.value.message
+    )
diff --git a/tests/async/test_issues.py b/tests/async/test_issues.py
index 0c46ec064..b6d17e2e3 100644
--- a/tests/async/test_issues.py
+++ b/tests/async/test_issues.py
@@ -12,19 +12,44 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from asyncio import FIRST_COMPLETED, CancelledError, create_task, wait
+from typing import Dict
+
 import pytest
 
+from playwright.async_api import Browser, BrowserType, Page, Playwright
+
 
 @pytest.mark.only_browser("chromium")
-async def test_issue_189(browser_type):
-    browser = await browser_type.launch(ignore_default_args=["--mute-audio"])
+async def test_issue_189(browser_type: BrowserType, launch_arguments: Dict) -> None:
+    browser = await browser_type.launch(
+        **launch_arguments, ignore_default_args=["--mute-audio"]
+    )
     page = await browser.new_page()
     assert await page.evaluate("1 + 1") == 2
     await browser.close()
 
 
 @pytest.mark.only_browser("chromium")
-async def test_issue_195(playwright, browser):
+async def test_issue_195(playwright: Playwright, browser: Browser) -> None:
     iphone_11 = playwright.devices["iPhone 11"]
     context = await browser.new_context(**iphone_11)
     await context.close()
+
+
+async def test_connection_task_cancel(page: Page) -> None:
+    await page.set_content("<input />")
+    done, pending = await wait(
+        {
+            create_task(page.wait_for_selector("input")),
+            create_task(page.wait_for_selector("#will-never-resolve")),
+        },
+        return_when=FIRST_COMPLETED,
+    )
+    assert len(done) == 1
+    assert len(pending) == 1
+    for task in pending:
+        task.cancel()
+        with pytest.raises(CancelledError):
+            await task
+    assert list(pending)[0].cancelled()
diff --git a/tests/async/test_jshandle.py b/tests/async/test_jshandle.py
index 3ce739680..f18cbd633 100644
--- a/tests/async/test_jshandle.py
+++ b/tests/async/test_jshandle.py
@@ -14,41 +14,45 @@
 
 import json
 import math
-from datetime import datetime
+from datetime import datetime, timezone
+from typing import Any, Dict
 
-from playwright.async_api import Error
+from playwright.async_api import Page
 
 
-async def test_jshandle_evaluate_work(page):
+async def test_jshandle_evaluate_work(page: Page) -> None:
     window_handle = await page.evaluate_handle("window")
     assert window_handle
+    assert (
+        repr(window_handle) == f"<JSHandle preview={window_handle._impl_obj._preview}>"
+    )
 
 
-async def test_jshandle_evaluate_accept_object_handle_as_argument(page):
+async def test_jshandle_evaluate_accept_object_handle_as_argument(page: Page) -> None:
     navigator_handle = await page.evaluate_handle("navigator")
     text = await page.evaluate("e => e.userAgent", navigator_handle)
     assert "Mozilla" in text
 
 
-async def test_jshandle_evaluate_accept_handle_to_primitive_types(page):
+async def test_jshandle_evaluate_accept_handle_to_primitive_types(page: Page) -> None:
     handle = await page.evaluate_handle("5")
     is_five = await page.evaluate("e => Object.is(e, 5)", handle)
     assert is_five
 
 
-async def test_jshandle_evaluate_accept_nested_handle(page):
+async def test_jshandle_evaluate_accept_nested_handle(page: Page) -> None:
     foo = await page.evaluate_handle('({ x: 1, y: "foo" })')
     result = await page.evaluate("({ foo }) => foo", {"foo": foo})
     assert result == {"x": 1, "y": "foo"}
 
 
-async def test_jshandle_evaluate_accept_nested_window_handle(page):
+async def test_jshandle_evaluate_accept_nested_window_handle(page: Page) -> None:
     foo = await page.evaluate_handle("window")
     result = await page.evaluate("({ foo }) => foo === window", {"foo": foo})
     assert result
 
 
-async def test_jshandle_evaluate_accept_multiple_nested_handles(page):
+async def test_jshandle_evaluate_accept_multiple_nested_handles(page: Page) -> None:
     foo = await page.evaluate_handle('({ x: 1, y: "foo" })')
     bar = await page.evaluate_handle("5")
     baz = await page.evaluate_handle('["baz"]')
@@ -62,30 +66,32 @@ async def test_jshandle_evaluate_accept_multiple_nested_handles(page):
     }
 
 
-async def test_jshandle_evaluate_throw_for_circular_objects(page):
-    a = {"x": 1}
+async def test_jshandle_evaluate_should_work_for_circular_objects(page: Page) -> None:
+    a: Dict[str, Any] = {"x": 1}
     a["y"] = a
-    error = None
-    try:
-        await page.evaluate("x => x", a)
-    except Error as e:
-        error = e
-    assert "Maximum argument depth exceeded" in error.message
+    result = await page.evaluate("a => { a.y.x += 1; return a; }", a)
+    assert result["x"] == 2
+    assert result["y"]["x"] == 2
+    assert result == result["y"]
 
 
-async def test_jshandle_evaluate_accept_same_nested_object_multiple_times(page):
+async def test_jshandle_evaluate_accept_same_nested_object_multiple_times(
+    page: Page,
+) -> None:
     foo = {"x": 1}
     assert await page.evaluate(
         "x => x", {"foo": foo, "bar": [foo], "baz": {"foo": foo}}
     ) == {"foo": {"x": 1}, "bar": [{"x": 1}], "baz": {"foo": {"x": 1}}}
 
 
-async def test_jshandle_evaluate_accept_object_handle_to_unserializable_value(page):
+async def test_jshandle_evaluate_accept_object_handle_to_unserializable_value(
+    page: Page,
+) -> None:
     handle = await page.evaluate_handle("() => Infinity")
     assert await page.evaluate("e => Object.is(e, Infinity)", handle)
 
 
-async def test_jshandle_evaluate_pass_configurable_args(page):
+async def test_jshandle_evaluate_pass_configurable_args(page: Page) -> None:
     result = await page.evaluate(
         """arg => {
             if (arg.foo !== 42)
@@ -103,7 +109,7 @@ async def test_jshandle_evaluate_pass_configurable_args(page):
     assert result == {}
 
 
-async def test_jshandle_properties_get_property(page):
+async def test_jshandle_properties_get_property(page: Page) -> None:
     handle1 = await page.evaluate_handle(
         """() => ({
             one: 1,
@@ -115,7 +121,9 @@ async def test_jshandle_properties_get_property(page):
     assert await handle2.json_value() == 2
 
 
-async def test_jshandle_properties_work_with_undefined_null_and_empty(page):
+async def test_jshandle_properties_work_with_undefined_null_and_empty(
+    page: Page,
+) -> None:
     handle = await page.evaluate_handle(
         """() => ({
             undefined: undefined,
@@ -130,7 +138,7 @@ async def test_jshandle_properties_work_with_undefined_null_and_empty(page):
     assert await empty_handle.json_value() is None
 
 
-async def test_jshandle_properties_work_with_unserializable_values(page):
+async def test_jshandle_properties_work_with_unserializable_values(page: Page) -> None:
     handle = await page.evaluate_handle(
         """() => ({
             infinity: Infinity,
@@ -149,7 +157,7 @@ async def test_jshandle_properties_work_with_unserializable_values(page):
     assert await neg_zero_handle.json_value() == float("-0")
 
 
-async def test_jshandle_properties_get_properties(page):
+async def test_jshandle_properties_get_properties(page: Page) -> None:
     handle = await page.evaluate_handle('() => ({ foo: "bar" })')
     properties = await handle.get_properties()
     assert "foo" in properties
@@ -157,59 +165,66 @@ async def test_jshandle_properties_get_properties(page):
     assert await foo.json_value() == "bar"
 
 
-async def test_jshandle_properties_return_empty_map_for_non_objects(page):
+async def test_jshandle_properties_return_empty_map_for_non_objects(page: Page) -> None:
     handle = await page.evaluate_handle("123")
     properties = await handle.get_properties()
     assert properties == {}
 
 
-async def test_jshandle_json_value_work(page):
+async def test_jshandle_json_value_work(page: Page) -> None:
     handle = await page.evaluate_handle('() => ({foo: "bar"})')
     json = await handle.json_value()
     assert json == {"foo": "bar"}
 
 
-async def test_jshandle_json_value_work_with_dates(page):
+async def test_jshandle_json_value_work_with_dates(page: Page) -> None:
     handle = await page.evaluate_handle('() => new Date("2020-05-27T01:31:38.506Z")')
     json = await handle.json_value()
-    assert json == datetime.fromisoformat("2020-05-27T01:31:38.506")
+    assert json == datetime.fromisoformat("2020-05-27T01:31:38.506").replace(
+        tzinfo=timezone.utc
+    )
 
 
-async def test_jshandle_json_value_throw_for_circular_object(page):
-    handle = await page.evaluate_handle("window")
-    error = None
-    try:
-        await handle.json_value()
-    except Error as e:
-        error = e
-    assert "Argument is a circular structure" in error.message
+async def test_jshandle_json_value_should_work_for_circular_object(page: Page) -> None:
+    handle = await page.evaluate_handle("const a = {}; a.b = a; a")
+    a: Dict[str, Any] = {}
+    a["b"] = a
+    result = await handle.json_value()
+    # Node test looks like the below, but assert isn't smart enough to handle this:
+    # assert await handle.json_value() == a
+    assert result["b"] == result
 
 
-async def test_jshandle_as_element_work(page):
+async def test_jshandle_as_element_work(page: Page) -> None:
     handle = await page.evaluate_handle("document.body")
     element = handle.as_element()
     assert element is not None
 
 
-async def test_jshandle_as_element_return_none_for_non_elements(page):
+async def test_jshandle_as_element_return_none_for_non_elements(page: Page) -> None:
     handle = await page.evaluate_handle("2")
     element = handle.as_element()
     assert element is None
 
 
-async def test_jshandle_to_string_work_for_primitives(page):
+async def test_jshandle_to_string_work_for_primitives(page: Page) -> None:
     number_handle = await page.evaluate_handle("2")
-    assert str(number_handle) == "JSHandle@2"
+    assert str(number_handle) == "2"
     string_handle = await page.evaluate_handle('"a"')
-    assert str(string_handle) == "JSHandle@a"
+    assert str(string_handle) == "a"
 
 
-async def test_jshandle_to_string_work_for_complicated_objects(page):
+async def test_jshandle_to_string_work_for_complicated_objects(
+    page: Page, browser_name: str
+) -> None:
     handle = await page.evaluate_handle("window")
-    assert str(handle) == "JSHandle@object"
+    if browser_name != "firefox":
+        assert str(handle) == "Window"
+    else:
+        assert str(handle) == "JSHandle@object"
 
 
-async def test_jshandle_to_string_work_for_promises(page):
+async def test_jshandle_to_string_work_for_promises(page: Page) -> None:
     handle = await page.evaluate_handle("({b: Promise.resolve(123)})")
     b_handle = await handle.get_property("b")
-    assert str(b_handle) == "JSHandle@promise"
+    assert str(b_handle) == "Promise"
diff --git a/tests/async/test_keyboard.py b/tests/async/test_keyboard.py
index 13fba1426..e175f429a 100644
--- a/tests/async/test_keyboard.py
+++ b/tests/async/test_keyboard.py
@@ -13,11 +13,13 @@
 # limitations under the License.
 import pytest
 
-from playwright._impl._api_types import Error
-from playwright.async_api import Page
+from playwright.async_api import Error, JSHandle, Page
+from tests.server import Server
 
+from .utils import Utils
 
-async def captureLastKeydown(page):
+
+async def captureLastKeydown(page: Page) -> JSHandle:
     lastEvent = await page.evaluate_handle(
         """() => {
         const lastEvent = {
@@ -43,7 +45,7 @@ async def captureLastKeydown(page):
     return lastEvent
 
 
-async def test_keyboard_type_into_a_textarea(page):
+async def test_keyboard_type_into_a_textarea(page: Page) -> None:
     await page.evaluate(
         """
             const textarea = document.createElement('textarea');
@@ -56,7 +58,7 @@ async def test_keyboard_type_into_a_textarea(page):
     assert await page.evaluate('document.querySelector("textarea").value') == text
 
 
-async def test_keyboard_move_with_the_arrow_keys(page, server):
+async def test_keyboard_move_with_the_arrow_keys(page: Page, server: Server) -> None:
     await page.goto(f"{server.PREFIX}/input/textarea.html")
     await page.type("textarea", "Hello World!")
     assert (
@@ -81,9 +83,12 @@ async def test_keyboard_move_with_the_arrow_keys(page, server):
     )
 
 
-async def test_keyboard_send_a_character_with_elementhandle_press(page, server):
+async def test_keyboard_send_a_character_with_elementhandle_press(
+    page: Page, server: Server
+) -> None:
     await page.goto(f"{server.PREFIX}/input/textarea.html")
     textarea = await page.query_selector("textarea")
+    assert textarea
     await textarea.press("a")
     assert await page.evaluate("document.querySelector('textarea').value") == "a"
     await page.evaluate(
@@ -93,7 +98,9 @@ async def test_keyboard_send_a_character_with_elementhandle_press(page, server):
     assert await page.evaluate("document.querySelector('textarea').value") == "a"
 
 
-async def test_should_send_a_character_with_send_character(page, server):
+async def test_should_send_a_character_with_send_character(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.focus("textarea")
     await page.keyboard.insert_text("嗨")
@@ -102,13 +109,14 @@ async def test_should_send_a_character_with_send_character(page, server):
         '() => window.addEventListener("keydown", e => e.preventDefault(), true)'
     )
     await page.keyboard.insert_text("a")
-    assert await page.evaluate('() => document.querySelector("textarea").value') == "嗨a"
+    assert (
+        await page.evaluate('() => document.querySelector("textarea").value') == "嗨a"
+    )
 
 
-async def test_should_only_emit_input_event(page, server):
+async def test_should_only_emit_input_event(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.focus("textarea")
-    page.on("console", "m => console.log(m.text())")
     events = await page.evaluate_handle(
         """() => {
     const events = [];
@@ -124,7 +132,9 @@ async def test_should_only_emit_input_event(page, server):
     assert await events.json_value() == ["input"]
 
 
-async def test_should_report_shiftkey(page: Page, server, is_mac, is_firefox):
+async def test_should_report_shiftkey(
+    page: Page, server: Server, is_mac: bool, is_firefox: bool
+) -> None:
     if is_firefox and is_mac:
         pytest.skip()
     await page.goto(server.PREFIX + "/input/keyboard.html")
@@ -179,7 +189,7 @@ async def test_should_report_shiftkey(page: Page, server, is_mac, is_firefox):
         )
 
 
-async def test_should_report_multiple_modifiers(page: Page, server):
+async def test_should_report_multiple_modifiers(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/keyboard.html")
     keyboard = page.keyboard
     await keyboard.down("Control")
@@ -211,7 +221,9 @@ async def test_should_report_multiple_modifiers(page: Page, server):
     assert await page.evaluate("() => getResult()") == "Keyup: Alt AltLeft 18 []"
 
 
-async def test_should_send_proper_codes_while_typing(page: Page, server):
+async def test_should_send_proper_codes_while_typing(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/keyboard.html")
     await page.keyboard.type("!")
     assert await page.evaluate("() => getResult()") == "\n".join(
@@ -231,7 +243,9 @@ async def test_should_send_proper_codes_while_typing(page: Page, server):
     )
 
 
-async def test_should_send_proper_codes_while_typing_with_shift(page: Page, server):
+async def test_should_send_proper_codes_while_typing_with_shift(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/keyboard.html")
     keyboard = page.keyboard
     await keyboard.down("Shift")
@@ -247,7 +261,7 @@ async def test_should_send_proper_codes_while_typing_with_shift(page: Page, serv
     await keyboard.up("Shift")
 
 
-async def test_should_not_type_canceled_events(page: Page, server):
+async def test_should_not_type_canceled_events(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.focus("textarea")
     await page.evaluate(
@@ -270,7 +284,7 @@ async def test_should_not_type_canceled_events(page: Page, server):
     )
 
 
-async def test_should_press_plus(page: Page, server):
+async def test_should_press_plus(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/keyboard.html")
     await page.keyboard.press("+")
     assert await page.evaluate("() => getResult()") == "\n".join(
@@ -282,7 +296,7 @@ async def test_should_press_plus(page: Page, server):
     )
 
 
-async def test_should_press_shift_plus(page: Page, server):
+async def test_should_press_shift_plus(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/keyboard.html")
     await page.keyboard.press("Shift++")
     assert await page.evaluate("() => getResult()") == "\n".join(
@@ -296,7 +310,9 @@ async def test_should_press_shift_plus(page: Page, server):
     )
 
 
-async def test_should_support_plus_separated_modifiers(page: Page, server):
+async def test_should_support_plus_separated_modifiers(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/keyboard.html")
     await page.keyboard.press("Shift+~")
     assert await page.evaluate("() => getResult()") == "\n".join(
@@ -310,7 +326,9 @@ async def test_should_support_plus_separated_modifiers(page: Page, server):
     )
 
 
-async def test_should_suport_multiple_plus_separated_modifiers(page: Page, server):
+async def test_should_suport_multiple_plus_separated_modifiers(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/keyboard.html")
     await page.keyboard.press("Control+Shift+~")
     assert await page.evaluate("() => getResult()") == "\n".join(
@@ -325,7 +343,7 @@ async def test_should_suport_multiple_plus_separated_modifiers(page: Page, serve
     )
 
 
-async def test_should_shift_raw_codes(page: Page, server):
+async def test_should_shift_raw_codes(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/keyboard.html")
     await page.keyboard.press("Shift+Digit3")
     assert await page.evaluate("() => getResult()") == "\n".join(
@@ -339,7 +357,7 @@ async def test_should_shift_raw_codes(page: Page, server):
     )
 
 
-async def test_should_specify_repeat_property(page: Page, server):
+async def test_should_specify_repeat_property(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.focus("textarea")
     lastEvent = await captureLastKeydown(page)
@@ -358,7 +376,7 @@ async def test_should_specify_repeat_property(page: Page, server):
     assert await lastEvent.evaluate("e => e.repeat") is False
 
 
-async def test_should_type_all_kinds_of_characters(page: Page, server):
+async def test_should_type_all_kinds_of_characters(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.focus("textarea")
     text = "This text goes onto two lines.\nThis character is 嗨."
@@ -366,7 +384,7 @@ async def test_should_type_all_kinds_of_characters(page: Page, server):
     assert await page.eval_on_selector("textarea", "t => t.value") == text
 
 
-async def test_should_specify_location(page: Page, server):
+async def test_should_specify_location(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     lastEvent = await captureLastKeydown(page)
     textarea = await page.query_selector("textarea")
@@ -385,12 +403,12 @@ async def test_should_specify_location(page: Page, server):
     assert await lastEvent.evaluate("e => e.location") == 3
 
 
-async def test_should_press_enter(page: Page, server):
+async def test_should_press_enter(page: Page) -> None:
     await page.set_content("<textarea></textarea>")
     await page.focus("textarea")
     lastEventHandle = await captureLastKeydown(page)
 
-    async def testEnterKey(key, expectedKey, expectedCode):
+    async def testEnterKey(key: str, expectedKey: str, expectedCode: str) -> None:
         await page.keyboard.press(key)
         lastEvent = await lastEventHandle.json_value()
         assert lastEvent["key"] == expectedKey
@@ -405,21 +423,21 @@ async def testEnterKey(key, expectedKey, expectedCode):
     await testEnterKey("\r", "Enter", "Enter")
 
 
-async def test_should_throw_unknown_keys(page: Page, server):
+async def test_should_throw_unknown_keys(page: Page, server: Server) -> None:
     with pytest.raises(Error) as exc:
         await page.keyboard.press("NotARealKey")
-    assert exc.value.message == 'Unknown key: "NotARealKey"'
+    assert exc.value.message == 'Keyboard.press: Unknown key: "NotARealKey"'
 
     with pytest.raises(Error) as exc:
         await page.keyboard.press("ё")
-    assert exc.value.message == 'Unknown key: "ё"'
+    assert exc.value.message == 'Keyboard.press: Unknown key: "ё"'
 
     with pytest.raises(Error) as exc:
         await page.keyboard.press("😊")
-    assert exc.value.message == 'Unknown key: "😊"'
+    assert exc.value.message == 'Keyboard.press: Unknown key: "😊"'
 
 
-async def test_should_type_emoji(page: Page, server):
+async def test_should_type_emoji(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.type("textarea", "👹 Tokyo street Japan 🇯🇵")
     assert (
@@ -428,7 +446,9 @@ async def test_should_type_emoji(page: Page, server):
     )
 
 
-async def test_should_type_emoji_into_an_iframe(page: Page, server, utils):
+async def test_should_type_emoji_into_an_iframe(
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await utils.attach_frame(page, "emoji-test", server.PREFIX + "/input/textarea.html")
     frame = page.frames[1]
@@ -441,22 +461,22 @@ async def test_should_type_emoji_into_an_iframe(page: Page, server, utils):
     )
 
 
-async def test_should_handle_select_all(page: Page, server, is_mac):
+async def test_should_handle_select_all(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     textarea = await page.query_selector("textarea")
     assert textarea
     await textarea.type("some text")
-    modifier = "Meta" if is_mac else "Control"
-    await page.keyboard.down(modifier)
+    await page.keyboard.down("ControlOrMeta")
     await page.keyboard.press("a")
-    await page.keyboard.up(modifier)
+    await page.keyboard.up("ControlOrMeta")
     await page.keyboard.press("Backspace")
     assert await page.eval_on_selector("textarea", "textarea => textarea.value") == ""
 
 
-async def test_should_be_able_to_prevent_select_all(page, server, is_mac):
+async def test_should_be_able_to_prevent_select_all(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     textarea = await page.query_selector("textarea")
+    assert textarea
     await textarea.type("some text")
     await page.eval_on_selector(
         "textarea",
@@ -468,10 +488,9 @@ async def test_should_be_able_to_prevent_select_all(page, server, is_mac):
   }""",
     )
 
-    modifier = "Meta" if is_mac else "Control"
-    await page.keyboard.down(modifier)
+    await page.keyboard.down("ControlOrMeta")
     await page.keyboard.press("a")
-    await page.keyboard.up(modifier)
+    await page.keyboard.up("ControlOrMeta")
     await page.keyboard.press("Backspace")
     assert (
         await page.eval_on_selector("textarea", "textarea => textarea.value")
@@ -480,9 +499,13 @@ async def test_should_be_able_to_prevent_select_all(page, server, is_mac):
 
 
 @pytest.mark.only_platform("darwin")
-async def test_should_support_macos_shortcuts(page, server, is_firefox, is_mac):
+@pytest.mark.skip_browser("firefox")  # Upstream issue
+async def test_should_support_macos_shortcuts(
+    page: Page, server: Server, is_firefox: bool, is_mac: bool
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     textarea = await page.query_selector("textarea")
+    assert textarea
     await textarea.type("some text")
     # select one word backwards
     await page.keyboard.press("Shift+Control+Alt+KeyB")
@@ -492,30 +515,21 @@ async def test_should_support_macos_shortcuts(page, server, is_firefox, is_mac):
     )
 
 
-async def test_should_press_the_meta_key(page, server, is_firefox, is_mac):
+async def test_should_press_the_meta_key(page: Page) -> None:
     lastEvent = await captureLastKeydown(page)
     await page.keyboard.press("Meta")
     v = await lastEvent.json_value()
     metaKey = v["metaKey"]
     key = v["key"]
     code = v["code"]
-    if is_firefox and not is_mac:
-        assert key == "OS"
-    else:
-        assert key == "Meta"
-
-    if is_firefox:
-        assert code == "OSLeft"
-    else:
-        assert code == "MetaLeft"
-
-    if is_firefox and not is_mac:
-        assert metaKey is False
-    else:
-        assert metaKey
+    assert key == "Meta"
+    assert code == "MetaLeft"
+    assert metaKey
 
 
-async def test_should_work_after_a_cross_origin_navigation(page, server):
+async def test_should_work_after_a_cross_origin_navigation(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/empty.html")
     await page.goto(server.CROSS_PROCESS_PREFIX + "/empty.html")
     lastEvent = await captureLastKeydown(page)
@@ -525,7 +539,9 @@ async def test_should_work_after_a_cross_origin_navigation(page, server):
 
 # event.keyIdentifier has been removed from all browsers except WebKit
 @pytest.mark.only_browser("webkit")
-async def test_should_expose_keyIdentifier_in_webkit(page, server):
+async def test_should_expose_keyIdentifier_in_webkit(
+    page: Page, server: Server
+) -> None:
     lastEvent = await captureLastKeydown(page)
     keyMap = {
         "ArrowUp": "Up",
@@ -544,7 +560,7 @@ async def test_should_expose_keyIdentifier_in_webkit(page, server):
         assert await lastEvent.evaluate("e => e.keyIdentifier") == keyIdentifier
 
 
-async def test_should_scroll_with_pagedown(page: Page, server):
+async def test_should_scroll_with_pagedown(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/scrollable.html")
     # A click is required for WebKit to send the event into the body.
     await page.click("body")
diff --git a/tests/async/test_launcher.py b/tests/async/test_launcher.py
index 008e43007..2b954fd61 100644
--- a/tests/async/test_launcher.py
+++ b/tests/async/test_launcher.py
@@ -14,85 +14,69 @@
 
 import asyncio
 import os
+from pathlib import Path
+from typing import Dict
 
 import pytest
 
 from playwright.async_api import BrowserType, Error
+from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
 
 
 async def test_browser_type_launch_should_reject_all_promises_when_browser_is_closed(
-    browser_type: BrowserType, launch_arguments
-):
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
     browser = await browser_type.launch(**launch_arguments)
     page = await (await browser.new_context()).new_page()
     never_resolves = asyncio.create_task(page.evaluate("() => new Promise(r => {})"))
     await page.close()
     with pytest.raises(Error) as exc:
         await never_resolves
-    assert "Protocol error" in exc.value.message
+    assert TARGET_CLOSED_ERROR_MESSAGE in exc.value.message
 
 
 @pytest.mark.skip_browser("firefox")
 async def test_browser_type_launch_should_throw_if_page_argument_is_passed(
-    browser_type, launch_arguments
-):
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
     with pytest.raises(Error) as exc:
         await browser_type.launch(**launch_arguments, args=["http://example.com"])
     assert "can not specify page" in exc.value.message
 
 
-@pytest.mark.skip("currently disabled on upstream")
 async def test_browser_type_launch_should_reject_if_launched_browser_fails_immediately(
-    browser_type, launch_arguments, assetdir
-):
+    browser_type: BrowserType, launch_arguments: Dict, assetdir: Path
+) -> None:
     with pytest.raises(Error):
         await browser_type.launch(
             **launch_arguments,
-            executable_path=assetdir / "dummy_bad_browser_executable.js"
+            executable_path=assetdir / "dummy_bad_browser_executable.js",
         )
 
 
-@pytest.mark.skip(
-    "does not return the expected error"
-)  # TODO: hangs currently on the bots
 async def test_browser_type_launch_should_reject_if_executable_path_is_invalid(
-    browser_type, launch_arguments
-):
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
     with pytest.raises(Error) as exc:
         await browser_type.launch(
             **launch_arguments, executable_path="random-invalid-path"
         )
-    assert "Failed to launch" in exc.value.message
+    assert "executable doesn't exist" in exc.value.message
 
 
-@pytest.mark.skip()
-async def test_browser_type_launch_server_should_return_child_process_instance(
-    browser_type, launch_arguments
-):
-    browser_server = await browser_type.launchServer(**launch_arguments)
-    assert browser_server.pid > 0
-    await browser_server.close()
-
-
-@pytest.mark.skip()
-async def test_browser_type_launch_server_should_fire_close_event(
-    browser_type, launch_arguments
-):
-    browser_server = await browser_type.launchServer(**launch_arguments)
-    close_event = asyncio.Future()
-    browser_server.on("close", lambda: close_event.set_result(None))
-    await asyncio.gather(close_event, browser_server.close())
-
-
-async def test_browser_type_executable_path_should_work(browser_type):
+async def test_browser_type_executable_path_should_work(
+    browser_type: BrowserType, browser_channel: str
+) -> None:
+    if browser_channel:
+        return
     executable_path = browser_type.executable_path
     assert os.path.exists(executable_path)
     assert os.path.realpath(executable_path) == os.path.realpath(executable_path)
 
 
 async def test_browser_type_name_should_work(
-    browser_type, is_webkit, is_firefox, is_chromium
-):
+    browser_type: BrowserType, is_webkit: bool, is_firefox: bool, is_chromium: bool
+) -> None:
     if is_webkit:
         assert browser_type.name == "webkit"
     elif is_firefox:
@@ -104,20 +88,31 @@ async def test_browser_type_name_should_work(
 
 
 async def test_browser_close_should_fire_close_event_for_all_contexts(
-    browser_type, launch_arguments
-):
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
     browser = await browser_type.launch(**launch_arguments)
     context = await browser.new_context()
     closed = []
-    context.on("close", lambda: closed.append(True))
+    context.on("close", lambda _: closed.append(True))
     await browser.close()
     assert closed == [True]
 
 
-async def test_browser_close_should_be_callable_twice(browser_type, launch_arguments):
+async def test_browser_close_should_be_callable_twice(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
     browser = await browser_type.launch(**launch_arguments)
     await asyncio.gather(
         browser.close(),
         browser.close(),
     )
     await browser.close()
+
+
+async def test_browser_type_launch_should_accept_ignore_default_args_false(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
+    # Regression for https://github.com/microsoft/playwright-python/issues/3005:
+    # passing False used to crash with "expected array, got boolean".
+    browser = await browser_type.launch(**launch_arguments, ignore_default_args=False)
+    await browser.close()
diff --git a/tests/async/test_listeners.py b/tests/async/test_listeners.py
index 9903beb8e..5185fd487 100644
--- a/tests/async/test_listeners.py
+++ b/tests/async/test_listeners.py
@@ -12,11 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from playwright.async_api import Page, Response
+from tests.server import Server
 
-async def test_listeners(page, server):
+
+async def test_listeners(page: Page, server: Server) -> None:
     log = []
 
-    def print_response(response):
+    def print_response(response: Response) -> None:
         log.append(response)
 
     page.on("response", print_response)
diff --git a/tests/async/test_locators.py b/tests/async/test_locators.py
new file mode 100644
index 000000000..d43a81c52
--- /dev/null
+++ b/tests/async/test_locators.py
@@ -0,0 +1,1360 @@
+# 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 os
+import re
+import traceback
+from pathlib import Path
+from typing import Callable
+from urllib.parse import urlparse
+
+import pytest
+
+from playwright._impl._path_utils import get_file_dirname
+from playwright.async_api import Error, Locator, Page, expect
+from tests.server import Server
+
+_dirname = get_file_dirname()
+FILE_TO_UPLOAD = _dirname / ".." / "assets/file-to-upload.txt"
+
+
+async def test_locators_click_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/button.html")
+    button = page.locator("button")
+    await button.click()
+    assert await page.evaluate("window['result']") == "Clicked"
+
+
+async def test_locators_click_should_work_with_node_removed(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/button.html")
+    await page.evaluate("delete window['Node']")
+    button = page.locator("button")
+    await button.click()
+    assert await page.evaluate("window['result']") == "Clicked"
+
+
+async def test_locators_click_should_work_for_text_nodes(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/button.html")
+    await page.evaluate(
+        """() => {
+        window['double'] = false;
+        const button = document.querySelector('button');
+        button.addEventListener('dblclick', event => {
+        window['double'] = true;
+        });
+    }"""
+    )
+    button = page.locator("button")
+    await button.dblclick()
+    assert await page.evaluate("double") is True
+    assert await page.evaluate("result") == "Clicked"
+
+
+async def test_locators_should_have_repr(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/button.html")
+    button = page.locator("button")
+    await button.click()
+    assert (
+        str(button)
+        == f"<Locator frame=<Frame name= url='{server.PREFIX}/input/button.html'> selector='button'>"
+    )
+
+
+async def test_locators_get_attribute_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/dom.html")
+    button = page.locator("#outer")
+    assert await button.get_attribute("name") == "value"
+    assert await button.get_attribute("foo") is None
+
+
+async def test_locators_input_value_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/dom.html")
+    await page.fill("#textarea", "input value")
+    text_area = page.locator("#textarea")
+    assert await text_area.input_value() == "input value"
+
+
+async def test_locators_inner_html_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/dom.html")
+    locator = page.locator("#outer")
+    assert await locator.inner_html() == '<div id="inner">Text,\nmore text</div>'
+
+
+async def test_locators_inner_text_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/dom.html")
+    locator = page.locator("#inner")
+    assert await locator.inner_text() == "Text, more text"
+
+
+async def test_locators_text_content_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/dom.html")
+    locator = page.locator("#inner")
+    assert await locator.text_content() == "Text,\nmore text"
+
+
+async def test_locators_is_hidden_and_is_visible_should_work(page: Page) -> None:
+    await page.set_content("<div>Hi</div><span></span>")
+
+    div = page.locator("div")
+    assert await div.is_visible() is True
+    assert await div.is_hidden() is False
+
+    span = page.locator("span")
+    assert await span.is_visible() is False
+    assert await span.is_hidden() is True
+
+
+async def test_locators_is_enabled_and_is_disabled_should_work(page: Page) -> None:
+    await page.set_content(
+        """
+        <button disabled>button1</button>
+        <button>button2</button>
+        <div>div</div>
+    """
+    )
+
+    div = page.locator("div")
+    assert await div.is_enabled()
+    assert await div.is_disabled() is False
+
+    button1 = page.locator(':text("button1")')
+    assert await button1.is_enabled() is False
+    assert await button1.is_disabled() is True
+
+    button1 = page.locator(':text("button2")')
+    assert await button1.is_enabled()
+    assert await button1.is_disabled() is False
+
+
+async def test_locators_is_editable_should_work(page: Page) -> None:
+    await page.set_content(
+        """
+        <input id=input1 disabled><textarea></textarea><input id=input2>
+    """
+    )
+
+    input1 = page.locator("#input1")
+    assert await input1.is_editable() is False
+
+    input2 = page.locator("#input2")
+    assert await input2.is_editable() is True
+
+
+async def test_locators_is_checked_should_work(page: Page) -> None:
+    await page.set_content(
+        """
+        <input type='checkbox' checked><div>Not a checkbox</div>
+    """
+    )
+
+    element = page.locator("input")
+    assert await element.is_checked() is True
+    await element.evaluate("e => e.checked = false")
+    assert await element.is_checked() is False
+
+
+async def test_locators_all_text_contents_should_work(page: Page) -> None:
+    await page.set_content(
+        """
+        <div>A</div><div>B</div><div>C</div>
+    """
+    )
+
+    element = page.locator("div")
+    assert await element.all_text_contents() == ["A", "B", "C"]
+
+
+async def test_locators_all_inner_texts(page: Page) -> None:
+    await page.set_content(
+        """
+        <div>A</div><div>B</div><div>C</div>
+    """
+    )
+
+    element = page.locator("div")
+    assert await element.all_inner_texts() == ["A", "B", "C"]
+
+
+async def test_locators_should_query_existing_element(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/playground.html")
+    await page.set_content(
+        """<html><body><div class="second"><div class="inner">A</div></div></body></html>"""
+    )
+    html = page.locator("html")
+    second = html.locator(".second")
+    inner = second.locator(".inner")
+    assert (
+        await page.evaluate("e => e.textContent", await inner.element_handle()) == "A"
+    )
+
+
+async def test_locators_evaluate_handle_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/dom.html")
+    outer = page.locator("#outer")
+    inner = outer.locator("#inner")
+    check = inner.locator("#check")
+    text = await inner.evaluate_handle("e => e.firstChild")
+    await page.evaluate("1 + 1")
+    assert (
+        str(outer)
+        == f"<Locator frame=<Frame name= url='{server.PREFIX}/dom.html'> selector='#outer'>"
+    )
+    assert (
+        str(inner)
+        == f"<Locator frame=<Frame name= url='{server.PREFIX}/dom.html'> selector='#outer >> #inner'>"
+    )
+    assert str(text) == "JSHandle@#text=Text,↵more text"
+    assert (
+        str(check)
+        == f"<Locator frame=<Frame name= url='{server.PREFIX}/dom.html'> selector='#outer >> #inner >> #check'>"
+    )
+
+
+async def test_locators_should_query_existing_elements(page: Page) -> None:
+    await page.set_content(
+        """<html><body><div>A</div><br/><div>B</div></body></html>"""
+    )
+    html = page.locator("html")
+    elements = await html.locator("div").element_handles()
+    assert len(elements) == 2
+    result = []
+    for element in elements:
+        result.append(await page.evaluate("e => e.textContent", element))
+    assert result == ["A", "B"]
+
+
+async def test_locators_return_empty_array_for_non_existing_elements(
+    page: Page,
+) -> None:
+    await page.set_content(
+        """<html><body><div>A</div><br/><div>B</div></body></html>"""
+    )
+    html = page.locator("html")
+    elements = await html.locator("abc").element_handles()
+    assert len(elements) == 0
+    assert elements == []
+
+
+async def test_locators_evaluate_all_should_work(page: Page) -> None:
+    await page.set_content(
+        """<html><body><div class="tweet"><div class="like">100</div><div class="like">10</div></div></body></html>"""
+    )
+    tweet = page.locator(".tweet .like")
+    content = await tweet.evaluate_all("nodes => nodes.map(n => n.innerText)")
+    assert content == ["100", "10"]
+
+
+async def test_locators_evaluate_all_should_work_with_missing_selector(
+    page: Page,
+) -> None:
+    await page.set_content(
+        """<div class="a">not-a-child-div</div><div id="myId"></div"""
+    )
+    tweet = page.locator("#myId .a")
+    nodes_length = await tweet.evaluate_all("nodes => nodes.length")
+    assert nodes_length == 0
+
+
+async def test_locators_hover_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/scrollable.html")
+    button = page.locator("#button-6")
+    await button.hover()
+    assert (
+        await page.evaluate("document.querySelector('button:hover').id") == "button-6"
+    )
+
+
+async def test_locators_fill_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/textarea.html")
+    button = page.locator("input")
+    await button.fill("some value")
+    assert await page.evaluate("result") == "some value"
+
+
+async def test_locators_clear_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/textarea.html")
+    button = page.locator("input")
+    await button.fill("some value")
+    assert await page.evaluate("result") == "some value"
+    await button.clear()
+    assert await page.evaluate("result") == ""
+
+
+async def test_locators_check_should_work(page: Page) -> None:
+    await page.set_content("<input id='checkbox' type='checkbox'></input>")
+    button = page.locator("input")
+    await button.check()
+    assert await page.evaluate("checkbox.checked") is True
+
+
+async def test_locators_uncheck_should_work(page: Page) -> None:
+    await page.set_content("<input id='checkbox' type='checkbox' checked></input>")
+    button = page.locator("input")
+    await button.uncheck()
+    assert await page.evaluate("checkbox.checked") is False
+
+
+async def test_locators_select_option_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    select = page.locator("select")
+    await select.select_option("blue")
+    assert await page.evaluate("result.onInput") == ["blue"]
+    assert await page.evaluate("result.onChange") == ["blue"]
+
+
+async def test_locators_focus_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/button.html")
+    button = page.locator("button")
+    assert await button.evaluate("button => document.activeElement === button") is False
+    await button.focus()
+    assert await button.evaluate("button => document.activeElement === button") is True
+
+
+async def test_locators_dispatch_event_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/button.html")
+    button = page.locator("button")
+    await button.dispatch_event("click")
+    assert await page.evaluate("result") == "Clicked"
+
+
+async def test_locators_should_upload_a_file(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/fileupload.html")
+    input = page.locator("input[type=file]")
+
+    file_path = os.path.relpath(FILE_TO_UPLOAD, os.getcwd())
+    await input.set_input_files(file_path)
+    assert (
+        await page.evaluate("e => e.files[0].name", await input.element_handle())
+        == "file-to-upload.txt"
+    )
+
+
+async def test_locators_should_press(page: Page) -> None:
+    await page.set_content("<input type='text' />")
+    await page.locator("input").press("h")
+    assert await page.eval_on_selector("input", "input => input.value") == "h"
+
+
+async def test_locators_should_scroll_into_view(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/offscreenbuttons.html")
+    for i in range(11):
+        button = page.locator(f"#btn{i}")
+        before = await button.evaluate(
+            "button => button.getBoundingClientRect().right - window.innerWidth"
+        )
+        assert before == 10 * i
+        await button.scroll_into_view_if_needed()
+        after = await button.evaluate(
+            "button => button.getBoundingClientRect().right - window.innerWidth"
+        )
+        assert after <= 0
+        await page.evaluate("window.scrollTo(0, 0)")
+
+
+async def test_locators_should_select_textarea(
+    page: Page, server: Server, browser_name: str
+) -> None:
+    await page.goto(server.PREFIX + "/input/textarea.html")
+    textarea = page.locator("textarea")
+    await textarea.evaluate("textarea => textarea.value = 'some value'")
+    await textarea.select_text()
+    if browser_name == "firefox" or browser_name == "webkit":
+        assert await textarea.evaluate("el => el.selectionStart") == 0
+        assert await textarea.evaluate("el => el.selectionEnd") == 10
+    else:
+        assert await page.evaluate("window.getSelection().toString()") == "some value"
+
+
+async def test_locators_should_type(page: Page) -> None:
+    await page.set_content("<input type='text' />")
+    await page.locator("input").type("hello")
+    assert await page.eval_on_selector("input", "input => input.value") == "hello"
+
+
+async def test_locators_should_press_sequentially(page: Page) -> None:
+    await page.set_content("<input type='text' />")
+    await page.locator("input").press_sequentially("hello")
+    assert await page.eval_on_selector("input", "input => input.value") == "hello"
+
+
+async def test_locators_should_screenshot(
+    page: Page, server: Server, assert_to_be_golden: Callable[[bytes, str], None]
+) -> None:
+    await page.set_viewport_size(
+        {
+            "width": 500,
+            "height": 500,
+        }
+    )
+    await page.goto(server.PREFIX + "/grid.html")
+    await page.evaluate("window.scrollBy(50, 100)")
+    element = page.locator(".box:nth-of-type(3)")
+    assert_to_be_golden(
+        await element.screenshot(), "screenshot-element-bounding-box.png"
+    )
+
+
+async def test_locators_should_return_bounding_box(page: Page, server: Server) -> None:
+    await page.set_viewport_size(
+        {
+            "width": 500,
+            "height": 500,
+        }
+    )
+    await page.goto(server.PREFIX + "/grid.html")
+    element = page.locator(".box:nth-of-type(13)")
+    box = await element.bounding_box()
+    assert box == {
+        "x": 100,
+        "y": 50,
+        "width": 50,
+        "height": 50,
+    }
+
+
+async def test_locators_should_respect_first_and_last(page: Page) -> None:
+    await page.set_content(
+        """
+        <section>
+            <div><p>A</p></div>
+            <div><p>A</p><p>A</p></div>
+            <div><p>A</p><p>A</p><p>A</p></div>
+        </section>"""
+    )
+    assert await page.locator("div >> p").count() == 6
+    assert await page.locator("div").locator("p").count() == 6
+    assert await page.locator("div").first.locator("p").count() == 1
+    assert await page.locator("div").last.locator("p").count() == 3
+
+
+async def test_locators_should_respect_nth(page: Page) -> None:
+    await page.set_content(
+        """
+    <section>
+        <div><p>A</p></div>
+        <div><p>A</p><p>A</p></div>
+        <div><p>A</p><p>A</p><p>A</p></div>
+    </section>"""
+    )
+    assert await page.locator("div >> p").nth(0).count() == 1
+    assert await page.locator("div").nth(1).locator("p").count() == 2
+    assert await page.locator("div").nth(2).locator("p").count() == 3
+
+
+async def test_locators_should_throw_on_capture_without_nth(page: Page) -> None:
+    await page.set_content(
+        """
+        <section><div><p>A</p></div></section>
+    """
+    )
+    with pytest.raises(Error, match="Can't query n-th element"):
+        await page.locator("*css=div >> p").nth(1).click()
+
+
+async def test_locators_should_throw_due_to_strictness(page: Page) -> None:
+    await page.set_content(
+        """
+        <div>A</div><div>B</div>
+    """
+    )
+    with pytest.raises(Error, match="strict mode violation"):
+        await page.locator("div").is_visible()
+
+
+async def test_locators_should_throw_due_to_strictness_2(page: Page) -> None:
+    await page.set_content(
+        """
+        <select><option>One</option><option>Two</option></select>
+    """
+    )
+    with pytest.raises(Error, match="strict mode violation"):
+        await page.locator("option").evaluate("e => {}")
+
+
+async def test_locators_set_checked(page: Page) -> None:
+    await page.set_content("`<input id='checkbox' type='checkbox'></input>`")
+    locator = page.locator("input")
+    await locator.set_checked(True)
+    assert await page.evaluate("checkbox.checked")
+    await locator.set_checked(False)
+    assert await page.evaluate("checkbox.checked") is False
+
+
+async def test_locators_wait_for(page: Page) -> None:
+    await page.set_content("<div></div>")
+    locator = page.locator("div")
+    task = locator.wait_for()
+    await page.eval_on_selector("div", "div => div.innerHTML = '<span>target</span>'")
+    await task
+    assert await locator.text_content() == "target"
+
+
+async def test_should_wait_for_hidden(page: Page) -> None:
+    await page.set_content("<div><span>target</span></div>")
+    locator = page.locator("span")
+    task = locator.wait_for(state="hidden")
+    await page.eval_on_selector("div", "div => div.innerHTML = ''")
+    await task
+
+
+async def test_should_combine_visible_with_other_selectors(page: Page) -> None:
+    await page.set_content(
+        """<div>
+        <div class="item" style="display: none">Hidden data0</div>
+        <div class="item">visible data1</div>
+        <div class="item" style="display: none">Hidden data1</div>
+        <div class="item">visible data2</div>
+        <div class="item" style="display: none">Hidden data1</div>
+        <div class="item">visible data3</div>
+        </div>
+    """
+    )
+    locator = page.locator(".item >> visible=true").nth(1)
+    await expect(locator).to_have_text("visible data2")
+    await expect(page.locator(".item >> visible=true >> text=data3")).to_have_text(
+        "visible data3"
+    )
+
+
+async def test_should_support_filter_visible(page: Page) -> None:
+    await page.set_content(
+        """<div>
+    <div class="item" style="display: none">Hidden data0</div>
+    <div class="item">visible data1</div>
+    <div class="item" style="display: none">Hidden data1</div>
+    <div class="item">visible data2</div>
+    <div class="item" style="display: none">Hidden data2</div>
+    <div class="item">visible data3</div>
+    </div>
+    """
+    )
+    locator = page.locator(".item").filter(visible=True).nth(1)
+    await expect(locator).to_have_text("visible data2")
+    await expect(
+        page.locator(".item").filter(visible=True).get_by_text("data3")
+    ).to_have_text("visible data3")
+    await expect(
+        page.locator(".item").filter(visible=False).get_by_text("data1")
+    ).to_have_text("Hidden data1")
+
+
+async def test_locator_count_should_work_with_deleted_map_in_main_world(
+    page: Page,
+) -> None:
+    await page.evaluate("Map = 1")
+    await page.locator("#searchResultTableDiv .x-grid3-row").count()
+    await expect(page.locator("#searchResultTableDiv .x-grid3-row")).to_have_count(0)
+
+
+async def test_locator_locator_and_framelocator_locator_should_accept_locator(
+    page: Page,
+) -> None:
+    await page.set_content(
+        """
+        <div><input value=outer></div>
+        <iframe srcdoc="<div><input value=inner></div>"></iframe>
+    """
+    )
+
+    input_locator = page.locator("input")
+    assert await input_locator.input_value() == "outer"
+    assert await page.locator("div").locator(input_locator).input_value() == "outer"
+    assert (
+        await page.frame_locator("iframe").locator(input_locator).input_value()
+        == "inner"
+    )
+    assert (
+        await page.frame_locator("iframe")
+        .locator("div")
+        .locator(input_locator)
+        .input_value()
+        == "inner"
+    )
+
+    div_locator = page.locator("div")
+    assert await div_locator.locator("input").input_value() == "outer"
+    assert (
+        await page.frame_locator("iframe")
+        .locator(div_locator)
+        .locator("input")
+        .input_value()
+        == "inner"
+    )
+
+
+async def route_iframe(page: Page) -> None:
+    await page.route(
+        "**/empty.html",
+        lambda route: route.fulfill(
+            body='<iframe src="iframe.html" name="frame1">></iframe>',
+            content_type="text/html",
+        ),
+    )
+    await page.route(
+        "**/iframe.html",
+        lambda route: route.fulfill(
+            body="""<html>
+          <div>
+            <button>Hello iframe</button>
+            <iframe src="iframe-2.html"></iframe>
+          </div>
+          <span>1</span>
+          <span>2</span>
+        </html>""",
+            content_type="text/html",
+        ),
+    )
+    await page.route(
+        "**/iframe-2.html",
+        lambda route: route.fulfill(
+            body="<html><button>Hello nested iframe</button></html>",
+            content_type="text/html",
+        ),
+    )
+
+
+async def test_locators_frame_should_work_with_iframe(
+    page: Page, server: Server
+) -> None:
+    await route_iframe(page)
+    await page.goto(server.EMPTY_PAGE)
+    button = page.frame_locator("iframe").locator("button")
+    await button.wait_for()
+    assert await button.inner_text() == "Hello iframe"
+    await button.click()
+
+
+async def test_locators_frame_should_work_for_nested_iframe(
+    page: Page, server: Server
+) -> None:
+    await route_iframe(page)
+    await page.goto(server.EMPTY_PAGE)
+    button = page.frame_locator("iframe").frame_locator("iframe").locator("button")
+    await button.wait_for()
+    assert await button.inner_text() == "Hello nested iframe"
+    await button.click()
+
+
+async def test_locators_frame_should_work_with_locator_frame_locator(
+    page: Page, server: Server
+) -> None:
+    await route_iframe(page)
+    await page.goto(server.EMPTY_PAGE)
+    button = page.locator("body").frame_locator("iframe").locator("button")
+    await button.wait_for()
+    assert await button.inner_text() == "Hello iframe"
+    await button.click()
+
+
+async def test_locator_content_frame_should_work(page: Page, server: Server) -> None:
+    await route_iframe(page)
+    await page.goto(server.EMPTY_PAGE)
+    locator = page.locator("iframe")
+    frame_locator = locator.content_frame
+    button = frame_locator.locator("button")
+    assert await button.inner_text() == "Hello iframe"
+    await expect(button).to_have_text("Hello iframe")
+    await button.click()
+
+
+async def test_frame_locator_owner_should_work(page: Page, server: Server) -> None:
+    await route_iframe(page)
+    await page.goto(server.EMPTY_PAGE)
+    frame_locator = page.frame_locator("iframe")
+    locator = frame_locator.owner
+    await expect(locator).to_be_visible()
+    assert await locator.get_attribute("name") == "frame1"
+
+
+async def route_ambiguous(page: Page) -> None:
+    await page.route(
+        "**/empty.html",
+        lambda route: route.fulfill(
+            body="""
+        <iframe src="iframe-1.html"></iframe>
+        <iframe src="iframe-2.html"></iframe>
+        <iframe src="iframe-3.html"></iframe>
+    """,
+            content_type="text/html",
+        ),
+    )
+    await page.route(
+        "**/iframe-*",
+        lambda route: route.fulfill(
+            body=f"<html><button>Hello from {urlparse(route.request.url).path[1:]}</button></html>",
+            content_type="text/html",
+        ),
+    )
+
+
+async def test_locator_frame_locator_should_throw_on_ambiguity(
+    page: Page, server: Server
+) -> None:
+    await route_ambiguous(page)
+    await page.goto(server.EMPTY_PAGE)
+    button = page.locator("body").frame_locator("iframe").locator("button")
+    with pytest.raises(
+        Error,
+        match=r'.*strict mode violation: locator\("body"\)\.locator\("iframe"\) resolved to 3 elements.*',
+    ):
+        await button.wait_for()
+
+
+async def test_locator_frame_locator_should_not_throw_on_first_last_nth(
+    page: Page, server: Server
+) -> None:
+    await route_ambiguous(page)
+    await page.goto(server.EMPTY_PAGE)
+    button1 = page.locator("body").frame_locator("iframe").first.locator("button")
+    assert await button1.text_content() == "Hello from iframe-1.html"
+    button2 = page.locator("body").frame_locator("iframe").nth(1).locator("button")
+    assert await button2.text_content() == "Hello from iframe-2.html"
+    button3 = page.locator("body").frame_locator("iframe").last.locator("button")
+    assert await button3.text_content() == "Hello from iframe-3.html"
+
+
+async def test_drag_to(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/drag-n-drop.html")
+    await page.locator("#source").drag_to(page.locator("#target"))
+    assert (
+        await page.eval_on_selector(
+            "#target", "target => target.contains(document.querySelector('#source'))"
+        )
+        is True
+    )
+
+
+async def test_drag_to_with_position(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content(
+        """
+      <div style="width:100px;height:100px;background:red;" id="red">
+      </div>
+      <div style="width:100px;height:100px;background:blue;" id="blue">
+      </div>
+    """
+    )
+    events_handle = await page.evaluate_handle(
+        """
+        () => {
+        const events = [];
+        document.getElementById('red').addEventListener('mousedown', event => {
+            events.push({
+            type: 'mousedown',
+            x: event.offsetX,
+            y: event.offsetY,
+            });
+        });
+        document.getElementById('blue').addEventListener('mouseup', event => {
+            events.push({
+            type: 'mouseup',
+            x: event.offsetX,
+            y: event.offsetY,
+            });
+        });
+        return events;
+        }
+    """
+    )
+    await page.locator("#red").drag_to(
+        page.locator("#blue"),
+        source_position={"x": 34, "y": 7},
+        target_position={"x": 10, "y": 20},
+    )
+    assert await events_handle.json_value() == [
+        {"type": "mousedown", "x": 34, "y": 7},
+        {"type": "mouseup", "x": 10, "y": 20},
+    ]
+
+
+async def test_locator_query_should_filter_by_text(page: Page, server: Server) -> None:
+    await page.set_content("<div>Foobar</div><div>Bar</div>")
+    await expect(page.locator("div", has_text="Foo")).to_have_text("Foobar")
+
+
+async def test_locator_query_should_filter_by_text_2(
+    page: Page, server: Server
+) -> None:
+    await page.set_content("<div>foo <span>hello world</span> bar</div>")
+    await expect(page.locator("div", has_text="hello world")).to_have_text(
+        "foo hello world bar"
+    )
+
+
+async def test_locator_query_should_filter_by_regex(page: Page, server: Server) -> None:
+    await page.set_content("<div>Foobar</div><div>Bar</div>")
+    await expect(page.locator("div", has_text=re.compile(r"Foo.*"))).to_have_text(
+        "Foobar"
+    )
+
+
+async def test_locator_query_should_filter_by_text_with_quotes(
+    page: Page, server: Server
+) -> None:
+    await page.set_content('<div>Hello "world"</div><div>Hello world</div>')
+    await expect(page.locator("div", has_text='Hello "world"')).to_have_text(
+        'Hello "world"'
+    )
+
+
+async def test_locator_query_should_filter_by_regex_with_quotes(
+    page: Page, server: Server
+) -> None:
+    await page.set_content('<div>Hello "world"</div><div>Hello world</div>')
+    await expect(
+        page.locator("div", has_text=re.compile('Hello "world"'))
+    ).to_have_text('Hello "world"')
+
+
+async def test_locator_query_should_filter_by_regex_and_regexp_flags(
+    page: Page, server: Server
+) -> None:
+    await page.set_content('<div>Hello "world"</div><div>Hello world</div>')
+    await expect(
+        page.locator("div", has_text=re.compile('hElLo "world', re.IGNORECASE))
+    ).to_have_text('Hello "world"')
+
+
+async def test_locator_should_return_page(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/frames/two-frames.html")
+    outer = page.locator("#outer")
+    assert outer.page == page
+
+    inner = outer.locator("#inner")
+    assert inner.page == page
+
+    in_frame = page.frames[1].locator("div")
+    assert in_frame.page == page
+
+
+async def test_locator_should_support_has_locator(page: Page, server: Server) -> None:
+    await page.set_content("<div><span>hello</span></div><div><span>world</span></div>")
+    await expect(page.locator("div", has=page.locator("text=world"))).to_have_count(1)
+    assert (
+        await page.locator("div", has=page.locator("text=world")).evaluate(
+            "e => e.outerHTML"
+        )
+        == "<div><span>world</span></div>"
+    )
+    await expect(page.locator("div", has=page.locator('text="hello"'))).to_have_count(1)
+    assert (
+        await page.locator("div", has=page.locator('text="hello"')).evaluate(
+            "e => e.outerHTML"
+        )
+        == "<div><span>hello</span></div>"
+    )
+    await expect(page.locator("div", has=page.locator("xpath=./span"))).to_have_count(2)
+    await expect(page.locator("div", has=page.locator("span"))).to_have_count(2)
+    await expect(
+        page.locator("div", has=page.locator("span", has_text="wor"))
+    ).to_have_count(1)
+    assert (
+        await page.locator("div", has=page.locator("span", has_text="wor")).evaluate(
+            "e => e.outerHTML"
+        )
+        == "<div><span>world</span></div>"
+    )
+    await expect(
+        page.locator(
+            "div",
+            has=page.locator("span"),
+            has_text="wor",
+        )
+    ).to_have_count(1)
+
+
+async def test_locator_should_enforce_same_frame_for_has_locator(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/frames/two-frames.html")
+    child = page.frames[1]
+    with pytest.raises(Error) as exc_info:
+        page.locator("div", has=child.locator("span"))
+    assert (
+        'Inner "has" locator must belong to the same frame.' in exc_info.value.message
+    )
+
+
+async def test_locator_should_support_locator_or(page: Page, server: Server) -> None:
+    await page.set_content("<div>hello</div><span>world</span>")
+    await expect(page.locator("div").or_(page.locator("span"))).to_have_count(2)
+    await expect(page.locator("div").or_(page.locator("span"))).to_have_text(
+        ["hello", "world"]
+    )
+    await expect(
+        page.locator("span").or_(page.locator("article")).or_(page.locator("div"))
+    ).to_have_text(["hello", "world"])
+    await expect(page.locator("article").or_(page.locator("someting"))).to_have_count(0)
+    await expect(page.locator("article").or_(page.locator("div"))).to_have_text("hello")
+    await expect(page.locator("article").or_(page.locator("span"))).to_have_text(
+        "world"
+    )
+    await expect(page.locator("div").or_(page.locator("article"))).to_have_text("hello")
+    await expect(page.locator("span").or_(page.locator("article"))).to_have_text(
+        "world"
+    )
+
+
+async def test_locator_should_support_locator_locator_with_and_or(page: Page) -> None:
+    await page.set_content(
+        """
+        <div>one <span>two</span> <button>three</button> </div>
+        <span>four</span>
+        <button>five</button>
+        """
+    )
+
+    await expect(page.locator("div").locator(page.locator("button"))).to_have_text(
+        ["three"]
+    )
+    await expect(
+        page.locator("div").locator(page.locator("button").or_(page.locator("span")))
+    ).to_have_text(["two", "three"])
+    await expect(page.locator("button").or_(page.locator("span"))).to_have_text(
+        ["two", "three", "four", "five"]
+    )
+
+    await expect(
+        page.locator("div").locator(
+            page.locator("button").and_(page.get_by_role("button"))
+        )
+    ).to_have_text(["three"])
+    await expect(page.locator("button").and_(page.get_by_role("button"))).to_have_text(
+        ["three", "five"]
+    )
+
+
+async def test_locator_highlight_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/grid.html")
+    await page.locator(".box").nth(3).highlight()
+    assert await page.locator("x-pw-glass").is_visible()
+
+
+async def test_should_support_locator_that(page: Page) -> None:
+    await page.set_content(
+        "<section><div><span>hello</span></div><div><span>world</span></div></section>"
+    )
+
+    await expect(page.locator("div").filter(has_text="hello")).to_have_count(1)
+    await expect(
+        page.locator("div", has_text="hello").filter(has_text="hello")
+    ).to_have_count(1)
+    await expect(
+        page.locator("div", has_text="hello").filter(has_text="world")
+    ).to_have_count(0)
+    await expect(
+        page.locator("section", has_text="hello").filter(has_text="world")
+    ).to_have_count(1)
+    await expect(
+        page.locator("div").filter(has_text="hello").locator("span")
+    ).to_have_count(1)
+    await expect(
+        page.locator("div").filter(has=page.locator("span", has_text="world"))
+    ).to_have_count(1)
+    await expect(page.locator("div").filter(has=page.locator("span"))).to_have_count(2)
+    await expect(
+        page.locator("div").filter(
+            has=page.locator("span"),
+            has_text="world",
+        )
+    ).to_have_count(1)
+
+
+async def test_should_filter_by_case_insensitive_regex_in_a_child(page: Page) -> None:
+    await page.set_content('<div class="test"><h5>Title Text</h5></div>')
+    await expect(
+        page.locator("div", has_text=re.compile(r"^title text$", re.I))
+    ).to_have_text("Title Text")
+
+
+async def test_should_filter_by_case_insensitive_regex_in_multiple_children(
+    page: Page,
+) -> None:
+    await page.set_content(
+        '<div class="test"><h5>Title</h5> <h2><i>Text</i></h2></div>'
+    )
+    await expect(
+        page.locator("div", has_text=re.compile(r"^title text$", re.I))
+    ).to_have_class("test")
+
+
+async def test_should_filter_by_regex_with_special_symbols(page: Page) -> None:
+    await page.set_content(
+        '<div class="test"><h5>First/"and"</h5><h2><i>Second\\</i></h2></div>'
+    )
+    await expect(
+        page.locator("div", has_text=re.compile(r'^first\/".*"second\\$', re.S | re.I))
+    ).to_have_class("test")
+
+
+async def test_should_support_locator_filter(page: Page) -> None:
+    await page.set_content(
+        "<section><div><span>hello</span></div><div><span>world</span></div></section>"
+    )
+
+    await expect(page.locator("div").filter(has_text="hello")).to_have_count(1)
+    await expect(
+        page.locator("div", has_text="hello").filter(has_text="hello")
+    ).to_have_count(1)
+    await expect(
+        page.locator("div", has_text="hello").filter(has_text="world")
+    ).to_have_count(0)
+    await expect(
+        page.locator("section", has_text="hello").filter(has_text="world")
+    ).to_have_count(1)
+    await expect(
+        page.locator("div").filter(has_text="hello").locator("span")
+    ).to_have_count(1)
+    await expect(
+        page.locator("div").filter(has=page.locator("span", has_text="world"))
+    ).to_have_count(1)
+    await expect(page.locator("div").filter(has=page.locator("span"))).to_have_count(2)
+    await expect(
+        page.locator("div").filter(
+            has=page.locator("span"),
+            has_text="world",
+        )
+    ).to_have_count(1)
+    await expect(
+        page.locator("div").filter(has_not=page.locator("span", has_text="world"))
+    ).to_have_count(1)
+    await expect(
+        page.locator("div").filter(has_not=page.locator("section"))
+    ).to_have_count(2)
+    await expect(
+        page.locator("div").filter(has_not=page.locator("span"))
+    ).to_have_count(0)
+
+    await expect(page.locator("div").filter(has_not_text="hello")).to_have_count(1)
+    await expect(page.locator("div").filter(has_not_text="foo")).to_have_count(2)
+
+
+async def test_locators_should_support_locator_and(page: Page, server: Server) -> None:
+    await page.set_content(
+        """
+        <div data-testid=foo>hello</div><div data-testid=bar>world</div>
+        <span data-testid=foo>hello2</span><span data-testid=bar>world2</span>
+    """
+    )
+    await expect(page.locator("div").and_(page.locator("div"))).to_have_count(2)
+    await expect(page.locator("div").and_(page.get_by_test_id("foo"))).to_have_text(
+        ["hello"]
+    )
+    await expect(page.locator("div").and_(page.get_by_test_id("bar"))).to_have_text(
+        ["world"]
+    )
+    await expect(page.get_by_test_id("foo").and_(page.locator("div"))).to_have_text(
+        ["hello"]
+    )
+    await expect(page.get_by_test_id("bar").and_(page.locator("span"))).to_have_text(
+        ["world2"]
+    )
+    await expect(
+        page.locator("span").and_(page.get_by_test_id(re.compile("bar|foo")))
+    ).to_have_count(2)
+
+
+async def test_locators_has_does_not_encode_unicode(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    locators = [
+        page.locator("button", has_text="Драматург"),
+        page.locator("button", has_text=re.compile("Драматург")),
+        page.locator("button", has=page.locator("text=Драматург")),
+    ]
+    for locator in locators:
+        with pytest.raises(Error) as exc_info:
+            await locator.click(timeout=1_000)
+        assert "Драматург" in exc_info.value.message
+
+
+async def test_locators_should_focus_and_blur_a_button(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/button.html")
+    button = page.locator("button")
+    assert not await button.evaluate("button => document.activeElement === button")
+
+    focused = False
+    blurred = False
+
+    async def focus_event() -> None:
+        nonlocal focused
+        focused = True
+
+    async def blur_event() -> None:
+        nonlocal blurred
+        blurred = True
+
+    await page.expose_function("focusEvent", focus_event)
+    await page.expose_function("blurEvent", blur_event)
+    await button.evaluate(
+        """button => {
+        button.addEventListener('focus', window['focusEvent']);
+        button.addEventListener('blur', window['blurEvent']);
+    }"""
+    )
+
+    await button.focus()
+    assert focused
+    assert not blurred
+    assert await button.evaluate("button => document.activeElement === button")
+
+    await button.blur()
+    assert focused
+    assert blurred
+    assert not await button.evaluate("button => document.activeElement === button")
+
+
+async def test_locator_all_should_work(page: Page) -> None:
+    await page.set_content("<div><p>A</p><p>B</p><p>C</p></div>")
+    texts = []
+    for p in await page.locator("p").all():
+        texts.append(await p.text_content())
+    assert texts == ["A", "B", "C"]
+
+
+async def test_locator_click_timeout_error_should_contain_call_log(page: Page) -> None:
+    with pytest.raises(Error) as exc_info:
+        await page.get_by_role("button", name="Hello Python").click(timeout=42)
+    formatted_exception = "".join(
+        traceback.format_exception(type(exc_info.value), value=exc_info.value, tb=None)
+    )
+    assert "Locator.click: Timeout 42ms exceeded." in formatted_exception
+    assert (
+        'waiting for get_by_role("button", name="Hello Python")' in formatted_exception
+    )
+    assert (
+        "During handling of the above exception, another exception occurred"
+        not in formatted_exception
+    )
+
+
+async def test_locator_should_ignore_deprecated_is_hidden_and_visible_timeout(
+    page: Page,
+) -> None:
+    await page.set_content("<div>foo</div>")
+    div = page.locator("div")
+    assert await div.is_hidden(timeout=10) is False
+    assert await div.is_visible(timeout=10) is True
+
+
+async def test_description_should_return_none_for_locator_without_description(
+    page: Page,
+) -> None:
+    locator = page.locator("button")
+    assert locator.description is None
+
+
+async def test_description_should_return_description_for_locator_with_simple_description(
+    page: Page,
+) -> None:
+    locator = page.locator("button").describe("Submit button")
+    assert locator.description == "Submit button"
+
+
+async def test_description_should_return_description_with_special_characters(
+    page: Page,
+) -> None:
+    locator = page.locator("div").describe("Button with \"quotes\" and 'apostrophes'")
+    assert locator.description == "Button with \"quotes\" and 'apostrophes'"
+
+
+async def test_description_should_return_description_for_chained_locators(
+    page: Page,
+) -> None:
+    locator = page.locator("form").locator("input").describe("Form input field")
+    assert locator.description == "Form input field"
+
+
+async def test_description_should_return_description_for_locator_with_multiple_describe_calls(
+    page: Page,
+) -> None:
+    locator1 = page.locator("foo").describe("First description")
+    assert locator1.description == "First description"
+    locator2 = locator1.locator("button").describe("Second description")
+    assert locator2.description == "Second description"
+    locator3 = locator2.locator("button")
+    assert locator3.description is None
+
+
+async def test_normalize_should_resolve_to_a_locator(page: Page) -> None:
+    await page.set_content("<button>Click me</button>")
+    normalized = await page.get_by_role("button").normalize()
+    assert await normalized.text_content() == "Click me"
+
+
+_DROPZONE_HTML = """
+    <style>#dropzone { width: 300px; height: 200px; border: 2px dashed #888; }</style>
+    <div id="dropzone"></div>
+    <script>
+      window.__dropInfo = null;
+      const zone = document.getElementById('dropzone');
+      zone.addEventListener('dragenter', e => e.preventDefault());
+      zone.addEventListener('dragover', e => e.preventDefault());
+      zone.addEventListener('drop', async e => {
+        e.preventDefault();
+        const files = [];
+        for (const file of e.dataTransfer.files)
+          files.push({ name: file.name, type: file.type, size: file.size, text: await file.text() });
+        const data = {};
+        for (const t of e.dataTransfer.types) {
+          if (t !== 'Files')
+            data[t] = e.dataTransfer.getData(t);
+        }
+        window.__dropInfo = { files, data };
+      });
+    </script>
+"""
+
+
+async def _get_drop_info(page: Page) -> dict:
+    handle = await page.wait_for_function("() => window.__dropInfo")
+    return await handle.json_value()
+
+
+async def test_drop_should_drop_a_file_payload(page: Page) -> None:
+    await page.set_content(_DROPZONE_HTML)
+    await page.locator("#dropzone").drop(
+        {"files": {"name": "note.txt", "mimeType": "text/plain", "buffer": b"hello"}}
+    )
+    info = await _get_drop_info(page)
+    assert info == {
+        "files": [
+            {"name": "note.txt", "type": "text/plain", "size": 5, "text": "hello"}
+        ],
+        "data": {},
+    }
+
+
+async def test_drop_should_drop_multiple_file_payloads(page: Page) -> None:
+    await page.set_content(_DROPZONE_HTML)
+    files: list = [
+        {"name": "a.txt", "mimeType": "text/plain", "buffer": b"AAA"},
+        {"name": "b.txt", "mimeType": "text/plain", "buffer": b"BB"},
+    ]
+    await page.locator("#dropzone").drop({"files": files})
+    info = await _get_drop_info(page)
+    assert [(f["name"], f["text"]) for f in info["files"]] == [
+        ("a.txt", "AAA"),
+        ("b.txt", "BB"),
+    ]
+
+
+async def test_drop_should_drop_a_file_by_local_path(
+    page: Page, tmp_path: Path
+) -> None:
+    await page.set_content(_DROPZONE_HTML)
+    file_path = tmp_path / "hello.txt"
+    file_path.write_text("path-content")
+    await page.locator("#dropzone").drop({"files": str(file_path)})
+    info = await _get_drop_info(page)
+    assert len(info["files"]) == 1
+    assert info["files"][0]["name"] == "hello.txt"
+    assert info["files"][0]["text"] == "path-content"
+
+
+async def test_drop_should_drop_clipboard_like_data(page: Page) -> None:
+    await page.set_content(_DROPZONE_HTML)
+    await page.locator("#dropzone").drop(
+        {"data": {"text/plain": "hello world", "text/uri-list": "https://example.com"}}
+    )
+    info = await _get_drop_info(page)
+    assert info["files"] == []
+    assert info["data"]["text/plain"] == "hello world"
+    assert info["data"]["text/uri-list"] == "https://example.com"
+
+
+async def test_drop_should_drop_files_and_data_together(page: Page) -> None:
+    await page.set_content(_DROPZONE_HTML)
+    await page.locator("#dropzone").drop(
+        {
+            "files": {"name": "mix.txt", "mimeType": "text/plain", "buffer": b"mix"},
+            "data": {"text/plain": "label"},
+        }
+    )
+    info = await _get_drop_info(page)
+    assert info["files"][0]["text"] == "mix"
+    assert info["data"]["text/plain"] == "label"
+
+
+async def test_get_by_role_with_description(page: Page) -> None:
+    # Ported from upstream tests/page/selectors-get-by.spec.ts.
+    await page.set_content(
+        """
+        <div role="alert" aria-label="Upload successful" aria-description="File doc-2025.pdf was uploaded successfully">Alert 1</div>
+        <div role="alert" aria-label="Upload successful" aria-description="File report-2026.pdf was uploaded successfully">Alert 2</div>
+        <div role="alert" aria-label="Invalid file" aria-description="File demo.doc has an invalid file format">Alert 3</div>
+    """
+    )
+
+    async def texts(locator: Locator) -> list:
+        return await locator.evaluate_all("els => els.map(e => e.textContent)")
+
+    # description substring match (default)
+    assert await texts(page.get_by_role("alert", description="doc-2025")) == ["Alert 1"]
+    assert await texts(page.get_by_role("alert", description="report-2026")) == [
+        "Alert 2"
+    ]
+
+    # description with name combined
+    assert await texts(
+        page.get_by_role("alert", name="Upload successful", description="doc-2025")
+    ) == ["Alert 1"]
+    assert await texts(
+        page.get_by_role("alert", name="Upload successful", description="report-2026")
+    ) == ["Alert 2"]
+    assert (
+        await texts(
+            page.get_by_role("alert", name="Invalid file", description="doc-2025")
+        )
+        == []
+    )
+
+    # description exact match
+    assert (
+        await texts(page.get_by_role("alert", description="doc-2025", exact=True)) == []
+    )
+    assert await texts(
+        page.get_by_role(
+            "alert",
+            description="File doc-2025.pdf was uploaded successfully",
+            exact=True,
+        )
+    ) == ["Alert 1"]
+
+    # description regex match
+    assert await texts(
+        page.get_by_role("alert", description=re.compile(r"report-\d+"))
+    ) == ["Alert 2"]
+    assert await texts(
+        page.get_by_role("alert", description=re.compile(r"uploaded successfully$"))
+    ) == ["Alert 1", "Alert 2"]
+
+
+async def test_get_by_role_with_description_whitespace_normalization(
+    page: Page,
+) -> None:
+    # Ported from upstream tests/page/selectors-get-by.spec.ts.
+    await page.set_content(
+        '<div role="alert" aria-description="File  doc-2025.pdf   was uploaded   successfully">Alert</div>'
+    )
+    assert await page.get_by_role(
+        "alert", description="  doc-2025.pdf \n was  uploaded "
+    ).evaluate_all("els => els.map(e => e.textContent)") == ["Alert"]
diff --git a/tests/async/test_navigation.py b/tests/async/test_navigation.py
index 7ebff83c0..a74d67533 100644
--- a/tests/async/test_navigation.py
+++ b/tests/async/test_navigation.py
@@ -15,31 +15,41 @@
 import asyncio
 import re
 import sys
-from typing import Any
+from pathlib import Path
+from typing import Any, List, Optional
 
 import pytest
 
-from playwright.async_api import Error, Request, TimeoutError
+from playwright.async_api import (
+    BrowserContext,
+    Error,
+    Page,
+    Request,
+    Response,
+    Route,
+    TimeoutError,
+)
+from tests.server import Server, TestServerRequest
 
 
-async def test_goto_should_work(page, server):
+async def test_goto_should_work(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     assert page.url == server.EMPTY_PAGE
 
 
-async def test_goto_should_work_with_file_URL(page, server, assetdir):
+async def test_goto_should_work_with_file_URL(page: Page, assetdir: Path) -> None:
     fileurl = (assetdir / "frames" / "two-frames.html").as_uri()
     await page.goto(fileurl)
     assert page.url.lower() == fileurl.lower()
     assert len(page.frames) == 3
 
 
-async def test_goto_should_use_http_for_no_protocol(page, server):
+async def test_goto_should_use_http_for_no_protocol(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE[7:])
     assert page.url == server.EMPTY_PAGE
 
 
-async def test_goto_should_work_cross_process(page, server):
+async def test_goto_should_work_cross_process(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     assert page.url == server.EMPTY_PAGE
 
@@ -53,13 +63,16 @@ def on_request(r: Request) -> None:
     page.on("request", on_request)
 
     response = await page.goto(url)
+    assert response
     assert page.url == url
     assert response.frame == page.main_frame
     assert request_frames[0] == page.main_frame
     assert response.url == url
 
 
-async def test_goto_should_capture_iframe_navigation_request(page, server):
+async def test_goto_should_capture_iframe_navigation_request(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     assert page.url == server.EMPTY_PAGE
 
@@ -72,6 +85,7 @@ def on_request(r: Request) -> None:
     page.on("request", on_request)
 
     response = await page.goto(server.PREFIX + "/frames/one-frame.html")
+    assert response
     assert page.url == server.PREFIX + "/frames/one-frame.html"
     assert response.frame == page.main_frame
     assert response.url == server.PREFIX + "/frames/one-frame.html"
@@ -81,8 +95,8 @@ def on_request(r: Request) -> None:
 
 
 async def test_goto_should_capture_cross_process_iframe_navigation_request(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     assert page.url == server.EMPTY_PAGE
 
@@ -95,6 +109,7 @@ def on_request(r: Request) -> None:
     page.on("request", on_request)
 
     response = await page.goto(server.CROSS_PROCESS_PREFIX + "/frames/one-frame.html")
+    assert response
     assert page.url == server.CROSS_PROCESS_PREFIX + "/frames/one-frame.html"
     assert response.frame == page.main_frame
     assert response.url == server.CROSS_PROCESS_PREFIX + "/frames/one-frame.html"
@@ -103,7 +118,9 @@ def on_request(r: Request) -> None:
     assert request_frames[0] == page.frames[1]
 
 
-async def test_goto_should_work_with_anchor_navigation(page, server):
+async def test_goto_should_work_with_anchor_navigation(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     assert page.url == server.EMPTY_PAGE
     await page.goto(server.EMPTY_PAGE + "#foo")
@@ -112,29 +129,33 @@ async def test_goto_should_work_with_anchor_navigation(page, server):
     assert page.url == server.EMPTY_PAGE + "#bar"
 
 
-async def test_goto_should_work_with_redirects(page, server):
+async def test_goto_should_work_with_redirects(page: Page, server: Server) -> None:
     server.set_redirect("/redirect/1.html", "/redirect/2.html")
     server.set_redirect("/redirect/2.html", "/empty.html")
     response = await page.goto(server.PREFIX + "/redirect/1.html")
+    assert response
     assert response.status == 200
     assert page.url == server.EMPTY_PAGE
 
 
-async def test_goto_should_navigate_to_about_blank(page, server):
+async def test_goto_should_navigate_to_about_blank(page: Page, server: Server) -> None:
     response = await page.goto("about:blank")
     assert response is None
 
 
 async def test_goto_should_return_response_when_page_changes_its_url_after_load(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     response = await page.goto(server.PREFIX + "/historyapi.html")
+    assert response
     assert response.status == 200
 
 
 @pytest.mark.skip_browser("firefox")
-async def test_goto_should_work_with_subframes_return_204(page, server):
-    def handle(request):
+async def test_goto_should_work_with_subframes_return_204(
+    page: Page, server: Server
+) -> None:
+    def handle(request: TestServerRequest) -> None:
         request.setResponseCode(204)
         request.finish()
 
@@ -144,10 +165,10 @@ def handle(request):
 
 
 async def test_goto_should_fail_when_server_returns_204(
-    page, server, is_chromium, is_webkit
-):
+    page: Page, server: Server, is_chromium: bool, is_webkit: bool
+) -> None:
     # WebKit just loads an empty page.
-    def handle(request):
+    def handle(request: TestServerRequest) -> None:
         request.setResponseCode(204)
         request.finish()
 
@@ -164,14 +185,17 @@ def handle(request):
         assert "NS_BINDING_ABORTED" in exc_info.value.message
 
 
-async def test_goto_should_navigate_to_empty_page_with_domcontentloaded(page, server):
+async def test_goto_should_navigate_to_empty_page_with_domcontentloaded(
+    page: Page, server: Server
+) -> None:
     response = await page.goto(server.EMPTY_PAGE, wait_until="domcontentloaded")
+    assert response
     assert response.status == 200
 
 
 async def test_goto_should_work_when_page_calls_history_api_in_beforeunload(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.evaluate(
         """() => {
@@ -180,12 +204,13 @@ async def test_goto_should_work_when_page_calls_history_api_in_beforeunload(
     )
 
     response = await page.goto(server.PREFIX + "/grid.html")
+    assert response
     assert response.status == 200
 
 
 async def test_goto_should_fail_when_navigating_to_bad_url(
-    page, server, is_chromium, is_webkit
-):
+    page: Page, is_chromium: bool, is_webkit: bool
+) -> None:
     with pytest.raises(Error) as exc_info:
         await page.goto("asdfasdf")
     if is_chromium or is_webkit:
@@ -195,16 +220,16 @@ async def test_goto_should_fail_when_navigating_to_bad_url(
 
 
 async def test_goto_should_fail_when_navigating_to_bad_ssl(
-    page, https_server, browser_name
-):
+    page: Page, https_server: Server, browser_name: str
+) -> None:
     with pytest.raises(Error) as exc_info:
         await page.goto(https_server.EMPTY_PAGE)
     expect_ssl_error(exc_info.value.message, browser_name)
 
 
 async def test_goto_should_fail_when_navigating_to_bad_ssl_after_redirects(
-    page, server, https_server, browser_name
-):
+    page: Page, server: Server, https_server: Server, browser_name: str
+) -> None:
     server.set_redirect("/redirect/1.html", "/redirect/2.html")
     server.set_redirect("/redirect/2.html", "/empty.html")
     with pytest.raises(Error) as exc_info:
@@ -213,38 +238,42 @@ async def test_goto_should_fail_when_navigating_to_bad_ssl_after_redirects(
 
 
 async def test_goto_should_not_crash_when_navigating_to_bad_ssl_after_a_cross_origin_navigation(
-    page, server, https_server, browser_name
-):
+    page: Page, server: Server, https_server: Server
+) -> None:
     await page.goto(server.CROSS_PROCESS_PREFIX + "/empty.html")
     with pytest.raises(Error):
         await page.goto(https_server.EMPTY_PAGE)
 
 
-async def test_goto_should_throw_if_networkidle2_is_passed_as_an_option(page, server):
+async def test_goto_should_throw_if_networkidle2_is_passed_as_an_option(
+    page: Page, server: Server
+) -> None:
     with pytest.raises(Error) as exc_info:
-        await page.goto(server.EMPTY_PAGE, wait_until="networkidle2")
+        await page.goto(server.EMPTY_PAGE, wait_until="networkidle2")  # type: ignore
     assert (
-        "wait_until: expected one of (load|domcontentloaded|networkidle)"
+        "wait_until: expected one of (load|domcontentloaded|networkidle|commit)"
         in exc_info.value.message
     )
 
 
 async def test_goto_should_fail_when_main_resources_failed_to_load(
-    page, server, is_chromium, is_webkit, is_win
-):
+    page: Page, is_chromium: bool, is_webkit: bool, is_win: bool
+) -> None:
     with pytest.raises(Error) as exc_info:
         await page.goto("http://localhost:44123/non-existing-url")
     if is_chromium:
         assert "net::ERR_CONNECTION_REFUSED" in exc_info.value.message
     elif is_webkit and is_win:
-        assert "Couldn't connect to server" in exc_info.value.message
+        assert "Could not connect to server" in exc_info.value.message
     elif is_webkit:
         assert "Could not connect" in exc_info.value.message
     else:
         assert "NS_ERROR_CONNECTION_REFUSED" in exc_info.value.message
 
 
-async def test_goto_should_fail_when_exceeding_maximum_navigation_timeout(page, server):
+async def test_goto_should_fail_when_exceeding_maximum_navigation_timeout(
+    page: Page, server: Server
+) -> None:
     # Hang for request to the empty.html
     server.set_route("/empty.html", lambda request: None)
     with pytest.raises(Error) as exc_info:
@@ -255,8 +284,8 @@ async def test_goto_should_fail_when_exceeding_maximum_navigation_timeout(page,
 
 
 async def test_goto_should_fail_when_exceeding_default_maximum_navigation_timeout(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     # Hang for request to the empty.html
     server.set_route("/empty.html", lambda request: None)
     page.context.set_default_navigation_timeout(2)
@@ -269,8 +298,8 @@ async def test_goto_should_fail_when_exceeding_default_maximum_navigation_timeou
 
 
 async def test_goto_should_fail_when_exceeding_browser_context_navigation_timeout(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     # Hang for request to the empty.html
     server.set_route("/empty.html", lambda request: None)
     page.context.set_default_navigation_timeout(2)
@@ -281,7 +310,9 @@ async def test_goto_should_fail_when_exceeding_browser_context_navigation_timeou
     assert isinstance(exc_info.value, TimeoutError)
 
 
-async def test_goto_should_fail_when_exceeding_default_maximum_timeout(page, server):
+async def test_goto_should_fail_when_exceeding_default_maximum_timeout(
+    page: Page, server: Server
+) -> None:
     # Hang for request to the empty.html
     server.set_route("/empty.html", lambda request: None)
     page.context.set_default_timeout(2)
@@ -293,7 +324,9 @@ async def test_goto_should_fail_when_exceeding_default_maximum_timeout(page, ser
     assert isinstance(exc_info.value, TimeoutError)
 
 
-async def test_goto_should_fail_when_exceeding_browser_context_timeout(page, server):
+async def test_goto_should_fail_when_exceeding_browser_context_timeout(
+    page: Page, server: Server
+) -> None:
     # Hang for request to the empty.html
     server.set_route("/empty.html", lambda request: None)
     page.context.set_default_timeout(2)
@@ -305,8 +338,8 @@ async def test_goto_should_fail_when_exceeding_browser_context_timeout(page, ser
 
 
 async def test_goto_should_prioritize_default_navigation_timeout_over_default_timeout(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     # Hang for request to the empty.html
     server.set_route("/empty.html", lambda request: None)
     page.set_default_timeout(0)
@@ -318,41 +351,54 @@ async def test_goto_should_prioritize_default_navigation_timeout_over_default_ti
     assert isinstance(exc_info.value, TimeoutError)
 
 
-async def test_goto_should_disable_timeout_when_its_set_to_0(page, server):
-    loaded = []
-    page.once("load", lambda: loaded.append(True))
+async def test_goto_should_disable_timeout_when_its_set_to_0(
+    page: Page, server: Server
+) -> None:
+    loaded: List[bool] = []
+    page.once("load", lambda _: loaded.append(True))
     await page.goto(server.PREFIX + "/grid.html", timeout=0, wait_until="load")
     assert loaded == [True]
 
 
-async def test_goto_should_work_when_navigating_to_valid_url(page, server):
+async def test_goto_should_work_when_navigating_to_valid_url(
+    page: Page, server: Server
+) -> None:
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.ok
 
 
-async def test_goto_should_work_when_navigating_to_data_url(page, server):
+async def test_goto_should_work_when_navigating_to_data_url(
+    page: Page, server: Server
+) -> None:
     response = await page.goto("data:text/html,hello")
     assert response is None
 
 
-async def test_goto_should_work_when_navigating_to_404(page, server):
+async def test_goto_should_work_when_navigating_to_404(
+    page: Page, server: Server
+) -> None:
     response = await page.goto(server.PREFIX + "/not-found")
+    assert response
     assert response.ok is False
     assert response.status == 404
 
 
-async def test_goto_should_return_last_response_in_redirect_chain(page, server):
+async def test_goto_should_return_last_response_in_redirect_chain(
+    page: Page, server: Server
+) -> None:
     server.set_redirect("/redirect/1.html", "/redirect/2.html")
     server.set_redirect("/redirect/2.html", "/redirect/3.html")
     server.set_redirect("/redirect/3.html", server.EMPTY_PAGE)
     response = await page.goto(server.PREFIX + "/redirect/1.html")
+    assert response
     assert response.ok
     assert response.url == server.EMPTY_PAGE
 
 
 async def test_goto_should_navigate_to_data_url_and_not_fire_dataURL_requests(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     requests = []
     page.on("request", lambda request: requests.append(request))
     dataURL = "data:text/html,<div>yo</div>"
@@ -362,26 +408,30 @@ async def test_goto_should_navigate_to_data_url_and_not_fire_dataURL_requests(
 
 
 async def test_goto_should_navigate_to_url_with_hash_and_fire_requests_without_hash(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     requests = []
     page.on("request", lambda request: requests.append(request))
     response = await page.goto(server.EMPTY_PAGE + "#hash")
+    assert response
     assert response.status == 200
     assert response.url == server.EMPTY_PAGE
     assert len(requests) == 1
     assert requests[0].url == server.EMPTY_PAGE
 
 
-async def test_goto_should_work_with_self_requesting_page(page, server):
+async def test_goto_should_work_with_self_requesting_page(
+    page: Page, server: Server
+) -> None:
     response = await page.goto(server.PREFIX + "/self-request.html")
+    assert response
     assert response.status == 200
     assert "self-request.html" in response.url
 
 
 async def test_goto_should_fail_when_navigating_and_show_the_url_at_the_error_message(
-    page, server, https_server
-):
+    page: Page, https_server: Server
+) -> None:
     url = https_server.PREFIX + "/redirect/1.html"
     with pytest.raises(Error) as exc_info:
         await page.goto(url)
@@ -389,14 +439,14 @@ async def test_goto_should_fail_when_navigating_and_show_the_url_at_the_error_me
 
 
 async def test_goto_should_be_able_to_navigate_to_a_page_controlled_by_service_worker(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/serviceworkers/fetch/sw.html")
     await page.evaluate("window.activationPromise")
     await page.goto(server.PREFIX + "/serviceworkers/fetch/sw.html")
 
 
-async def test_goto_should_send_referer(page, server):
+async def test_goto_should_send_referer(page: Page, server: Server) -> None:
     [request1, request2, _] = await asyncio.gather(
         server.wait_for_request("/grid.html"),
         server.wait_for_request("/digits/1.png"),
@@ -409,8 +459,8 @@ async def test_goto_should_send_referer(page, server):
 
 
 async def test_goto_should_reject_referer_option_when_set_extra_http_headers_provides_referer(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.set_extra_http_headers({"referer": "http://microsoft.com/"})
     with pytest.raises(Error) as exc_info:
         await page.goto(server.PREFIX + "/grid.html", referer="http://google.com/")
@@ -420,88 +470,73 @@ async def test_goto_should_reject_referer_option_when_set_extra_http_headers_pro
     assert server.PREFIX + "/grid.html" in exc_info.value.message
 
 
+async def test_goto_should_work_with_commit(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE, wait_until="commit")
+    assert page.url == server.EMPTY_PAGE
+
+
 async def test_network_idle_should_navigate_to_empty_page_with_networkidle(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     response = await page.goto(server.EMPTY_PAGE, wait_until="networkidle")
+    assert response
     assert response.status == 200
 
 
-async def test_wait_for_nav_should_work(page, server):
+async def test_wait_for_nav_should_work(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
-    [response, _] = await asyncio.gather(
-        page.wait_for_navigation(),
-        page.evaluate(
+    async with page.expect_navigation() as response_info:
+        await page.evaluate(
             "url => window.location.href = url", server.PREFIX + "/grid.html"
-        ),
-    )
+        )
+    response = await response_info.value
     assert response.ok
     assert "grid.html" in response.url
 
 
-async def test_wait_for_nav_should_respect_timeout(page, server):
-    asyncio.create_task(page.goto(server.EMPTY_PAGE))
+async def test_wait_for_nav_should_respect_timeout(page: Page, server: Server) -> None:
     with pytest.raises(Error) as exc_info:
-        await page.wait_for_navigation(url="**/frame.html", timeout=5000)
-    assert "Timeout 5000ms exceeded" in exc_info.value.message
-    # TODO: implement logging
-    # assert 'waiting for navigation to "**/frame.html" until "load"' in exc_info.value.message
-    # assert f'navigated to "{server.EMPTY_PAGE}"' in exc_info.value.message
+        async with page.expect_navigation(url="**/frame.html", timeout=2500):
+            await page.goto(server.EMPTY_PAGE)
+    assert "Timeout 2500ms exceeded" in exc_info.value.message
 
 
-@pytest.mark.skip("TODO: needs to be investigated, flaky")
 async def test_wait_for_nav_should_work_with_both_domcontentloaded_and_load(
-    page, server
-):
-    request = []
-
-    def handle(r):
-        request.append(r)
-
-    server.set_route("/one-style.css", handle)
-    navigation_task = asyncio.create_task(page.goto(server.PREFIX + "/one-style.html"))
-    dom_content_loaded_task = asyncio.create_task(
-        page.wait_for_navigation(wait_until="domcontentloaded")
-    )
-
-    both_fired = []
-    both_fired_task = asyncio.gather(
-        page.wait_for_navigation(wait_until="load"), dom_content_loaded_task
-    )
-    both_fired_task.add_done_callback(lambda: both_fired.append(True))
-
-    await server.wait_for_request("/one-style.css")
-    assert both_fired == []
-    request[0].finish()
-    await both_fired_task
-    await navigation_task
-
-
-async def test_wait_for_nav_should_work_with_clicking_on_anchor_links(page, server):
+    page: Page, server: Server
+) -> None:
+    async with (
+        page.expect_navigation(wait_until="domcontentloaded"),
+        page.expect_navigation(wait_until="load"),
+    ):
+        await page.goto(server.PREFIX + "/one-style.html")
+
+
+async def test_wait_for_nav_should_work_with_clicking_on_anchor_links(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.set_content('<a href="#foobar">foobar</a>')
-    [response, _] = await asyncio.gather(
-        page.wait_for_navigation(),
-        page.click("a"),
-    )
+    async with page.expect_navigation() as response_info:
+        await page.click("a")
+    response = await response_info.value
     assert response is None
     assert page.url == server.EMPTY_PAGE + "#foobar"
 
 
 async def test_wait_for_nav_should_work_with_clicking_on_links_which_do_not_commit_navigation(
-    page, server, https_server, browser_name
-):
+    page: Page, server: Server, https_server: Server, browser_name: str
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.set_content(f"<a href='{https_server.EMPTY_PAGE}'>foobar</a>")
     with pytest.raises(Error) as exc_info:
-        await asyncio.gather(
-            page.wait_for_navigation(),
-            page.click("a"),
-        )
+        async with page.expect_navigation():
+            await page.click("a")
     expect_ssl_error(exc_info.value.message, browser_name)
 
 
-async def test_wait_for_nav_should_work_with_history_push_state(page, server):
+async def test_wait_for_nav_should_work_with_history_push_state(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.set_content(
         """
@@ -511,15 +546,16 @@ async def test_wait_for_nav_should_work_with_history_push_state(page, server):
         </script>
     """
     )
-    [response, _] = await asyncio.gather(
-        page.wait_for_navigation(),
-        page.click("a"),
-    )
+    async with page.expect_navigation() as response_info:
+        await page.click("a")
+    response = await response_info.value
     assert response is None
     assert page.url == server.PREFIX + "/wow.html"
 
 
-async def test_wait_for_nav_should_work_with_history_replace_state(page, server):
+async def test_wait_for_nav_should_work_with_history_replace_state(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.set_content(
         """
@@ -529,61 +565,82 @@ async def test_wait_for_nav_should_work_with_history_replace_state(page, server)
         </script>
     """
     )
-    [response, _] = await asyncio.gather(
-        page.wait_for_navigation(),
-        page.click("a"),
-    )
+    async with page.expect_navigation() as response_info:
+        await page.click("a")
+    response = await response_info.value
     assert response is None
     assert page.url == server.PREFIX + "/replaced.html"
 
 
-async def test_wait_for_nav_should_work_with_dom_history_back_forward(page, server):
+async def test_wait_for_nav_should_work_with_dom_history_back_forward(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.set_content(
         """
-      <a id=back onclick='javascript:goBack()'>back</a>
-      <a id=forward onclick='javascript:goForward()'>forward</a>
+      <a id=back onclick='javascript:go_back()'>back</a>
+      <a id=forward onclick='javascript:go_forward()'>forward</a>
       <script>
-        function goBack() { history.back(); }
-        function goForward() { history.forward(); }
+        function go_back() { history.back(); }
+        function go_forward() { history.forward(); }
         history.pushState({}, '', '/first.html')
         history.pushState({}, '', '/second.html')
       </script>
     """
     )
     assert page.url == server.PREFIX + "/second.html"
-    [back_response, _] = await asyncio.gather(
-        page.wait_for_navigation(),
-        page.click("a#back"),
-    )
+    async with page.expect_navigation() as back_response_info:
+        await page.click("a#back")
+    back_response = await back_response_info.value
     assert back_response is None
     assert page.url == server.PREFIX + "/first.html"
-    [forward_response, _] = await asyncio.gather(
-        page.wait_for_navigation(),
-        page.click("a#forward"),
-    )
+    async with page.expect_navigation() as forward_response_info:
+        await page.click("a#forward")
+    forward_response = await forward_response_info.value
     assert forward_response is None
     assert page.url == server.PREFIX + "/second.html"
 
 
-@pytest.mark.skip_browser("firefox")
-async def test_wait_for_nav_should_work_when_subframe_issues_window_stop(page, server):
+@pytest.mark.skip_browser(
+    "webkit"
+)  # WebKit issues load event in some cases, but not always
+async def test_wait_for_nav_should_work_when_subframe_issues_window_stop(
+    page: Page, server: Server, is_webkit: bool
+) -> None:
     server.set_route("/frames/style.css", lambda _: None)
-    navigation_promise = asyncio.create_task(
-        page.goto(server.PREFIX + "/frames/one-frame.html")
-    )
-    await asyncio.sleep(0)
-    frame = await page.wait_for_event("frameattached")
-    await page.wait_for_event("framenavigated", lambda f: f == frame)
-    await asyncio.gather(frame.evaluate("() => window.stop()"), navigation_promise)
+    done = False
 
+    async def nav_and_mark_done() -> None:
+        nonlocal done
+        await page.goto(server.PREFIX + "/frames/one-frame.html")
+        done = True
 
-async def test_wait_for_nav_should_work_with_url_match(page, server):
-    responses = [None, None, None]
+    task = asyncio.create_task(nav_and_mark_done())
+    await asyncio.sleep(0)
+    async with page.expect_event("frameattached") as frame_info:
+        pass
+    frame = await frame_info.value
+
+    async with page.expect_event("framenavigated", lambda f: f == frame):
+        pass
+    await frame.evaluate("() => window.stop()")
+    await page.wait_for_timeout(2000)  # give it some time to erroneously resolve
+    assert done == (
+        not is_webkit
+    )  # Chromium and Firefox issue load event in this case.
+    if is_webkit:
+        task.cancel()
+
+
+async def test_wait_for_nav_should_work_with_url_match(
+    page: Page, server: Server
+) -> None:
+    responses: List[Optional[Response]] = [None, None, None]
 
     async def wait_for_nav(url: Any, index: int) -> None:
-        response = await page.wait_for_navigation(url=url)
-        responses[index] = response
+        async with page.expect_navigation(url=url) as response_info:
+            pass
+        responses[index] = await response_info.value
 
     response0_promise = asyncio.create_task(
         wait_for_nav(re.compile(r"one-style\.html"), 0)
@@ -619,46 +676,35 @@ async def wait_for_nav(url: Any, index: int) -> None:
 
 
 async def test_wait_for_nav_should_work_with_url_match_for_same_document_navigations(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
-    resolved = []
-    wait_task = asyncio.create_task(
-        page.wait_for_navigation(url=re.compile(r"third\.html"))
-    )
-    wait_task.add_done_callback(lambda _: resolved.append(True))
-    assert resolved == []
-    await page.evaluate("history.pushState({}, '', '/first.html')")
-
-    assert resolved == []
-    await page.evaluate("history.pushState({}, '', '/second.html')")
-
-    assert resolved == []
-    await page.evaluate("history.pushState({}, '', '/third.html')")
-
-    await wait_task
-    await asyncio.sleep(0)  # Let add_done_callback trigger
-    assert resolved == [True]
-
-
-async def test_wait_for_nav_should_work_for_cross_process_navigations(page, server):
+    async with page.expect_navigation(url=re.compile(r"third\.html")) as response_info:
+        assert not response_info.is_done()
+        await page.evaluate("history.pushState({}, '', '/first.html')")
+        assert not response_info.is_done()
+        await page.evaluate("history.pushState({}, '', '/second.html')")
+        assert not response_info.is_done()
+        await page.evaluate("history.pushState({}, '', '/third.html')")
+    assert response_info.is_done()
+
+
+async def test_wait_for_nav_should_work_for_cross_process_navigations(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
-    wait_task = asyncio.create_task(
-        page.wait_for_navigation(wait_until="domcontentloaded")
-    )
-    await asyncio.sleep(0)
     url = server.CROSS_PROCESS_PREFIX + "/empty.html"
-    goto_task = asyncio.create_task(page.goto(url))
-    response = await wait_task
+    async with page.expect_navigation(wait_until="domcontentloaded") as response_info:
+        await page.goto(url)
+    response = await response_info.value
     assert response.url == url
     assert page.url == url
     assert await page.evaluate("document.location.href") == url
-    await goto_task
 
 
 async def test_expect_navigation_should_work_for_cross_process_navigations(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     url = server.CROSS_PROCESS_PREFIX + "/empty.html"
     async with page.expect_navigation(wait_until="domcontentloaded") as response_info:
@@ -670,29 +716,23 @@ async def test_expect_navigation_should_work_for_cross_process_navigations(
     await goto_task
 
 
-@pytest.mark.skip("flaky, investigate")
-async def test_wait_for_load_state_should_pick_up_ongoing_navigation(page, server):
-    requests = []
-
-    def handler(request: Any):
-        requests.append(request)
-
-    server.set_route("/one-style.css", handler)
-
-    await asyncio.gather(
-        server.wait_for_request("/one-style.css"),
-        page.goto(server.PREFIX + "/one-style.html", wait_until="domcontentloaded"),
-    )
-
-    async with page.expect_load_state():
-        requests[0].setResponseCode(404)
-        requests[0].finish()
+async def test_wait_for_nav_should_work_with_commit(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    async with page.expect_navigation(wait_until="commit") as response_info:
+        await page.evaluate(
+            "url => window.location.href = url", server.PREFIX + "/grid.html"
+        )
+    response = await response_info.value
+    assert response.ok
+    assert "grid.html" in response.url
 
 
-async def test_wait_for_load_state_should_respect_timeout(page, server):
+async def test_wait_for_load_state_should_respect_timeout(
+    page: Page, server: Server
+) -> None:
     requests = []
 
-    def handler(request: Any):
+    def handler(request: Any) -> None:
         requests.append(request)
 
     server.set_route("/one-style.css", handler)
@@ -703,29 +743,33 @@ def handler(request: Any):
     assert "Timeout 1ms exceeded." in exc_info.value.message
 
 
-async def test_wait_for_load_state_should_resolve_immediately_if_loaded(page, server):
+async def test_wait_for_load_state_should_resolve_immediately_if_loaded(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/one-style.html")
     await page.wait_for_load_state()
 
 
-async def test_wait_for_load_state_should_throw_for_bad_state(page, server):
+async def test_wait_for_load_state_should_throw_for_bad_state(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/one-style.html")
     with pytest.raises(Error) as exc_info:
-        await page.wait_for_load_state("bad")
+        await page.wait_for_load_state("bad")  # type: ignore
     assert (
-        "state: expected one of (load|domcontentloaded|networkidle)"
+        "state: expected one of (load|domcontentloaded|networkidle|commit)"
         in exc_info.value.message
     )
 
 
 async def test_wait_for_load_state_should_resolve_immediately_if_load_state_matches(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
 
     requests = []
 
-    def handler(request: Any):
+    def handler(request: Any) -> None:
         requests.append(request)
 
     server.set_route("/one-style.css", handler)
@@ -734,9 +778,17 @@ def handler(request: Any):
     await page.wait_for_load_state("domcontentloaded")
 
 
+async def test_wait_for_load_state_networkidle(page: Page, server: Server) -> None:
+    wait_for_network_idle_future = asyncio.create_task(
+        page.wait_for_load_state("networkidle")
+    )
+    await page.goto(server.PREFIX + "/networkidle.html")
+    await wait_for_network_idle_future
+
+
 async def test_wait_for_load_state_should_work_with_pages_that_have_loaded_before_being_connected_to(
-    page, context, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     async with page.expect_popup() as popup_info:
         await page.evaluate("window._popup = window.open(document.location.href)")
@@ -749,8 +801,8 @@ async def test_wait_for_load_state_should_work_with_pages_that_have_loaded_befor
 
 
 async def test_wait_for_load_state_should_wait_for_load_state_of_empty_url_popup(
-    browser, page, is_firefox
-):
+    page: Page,
+) -> None:
     ready_state = []
     async with page.expect_popup() as popup_info:
         ready_state.append(
@@ -764,13 +816,13 @@ async def test_wait_for_load_state_should_wait_for_load_state_of_empty_url_popup
 
     popup = await popup_info.value
     await popup.wait_for_load_state()
-    assert ready_state == ["uninitialized"] if is_firefox else ["complete"]
+    assert ready_state == ["complete"]
     assert await popup.evaluate("() => document.readyState") == ready_state[0]
 
 
 async def test_wait_for_load_state_should_wait_for_load_state_of_about_blank_popup_(
-    browser, page
-):
+    page: Page,
+) -> None:
     async with page.expect_popup() as popup_info:
         await page.evaluate("window.open('about:blank') && 1")
     popup = await popup_info.value
@@ -779,8 +831,8 @@ async def test_wait_for_load_state_should_wait_for_load_state_of_about_blank_pop
 
 
 async def test_wait_for_load_state_should_wait_for_load_state_of_about_blank_popup_with_noopener(
-    browser, page
-):
+    page: Page,
+) -> None:
     async with page.expect_popup() as popup_info:
         await page.evaluate("window.open('about:blank', null, 'noopener') && 1")
 
@@ -790,8 +842,8 @@ async def test_wait_for_load_state_should_wait_for_load_state_of_about_blank_pop
 
 
 async def test_wait_for_load_state_should_wait_for_load_state_of_popup_with_network_url_(
-    browser, page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     async with page.expect_popup() as popup_info:
         await page.evaluate("url => window.open(url) && 1", server.EMPTY_PAGE)
@@ -802,8 +854,8 @@ async def test_wait_for_load_state_should_wait_for_load_state_of_popup_with_netw
 
 
 async def test_wait_for_load_state_should_wait_for_load_state_of_popup_with_network_url_and_noopener_(
-    browser, page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     async with page.expect_popup() as popup_info:
         await page.evaluate(
@@ -816,8 +868,8 @@ async def test_wait_for_load_state_should_wait_for_load_state_of_popup_with_netw
 
 
 async def test_wait_for_load_state_should_work_with_clicking_target__blank(
-    browser, page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.set_content(
         '<a target=_blank rel="opener" href="/one-style.html">yo</a>'
@@ -829,9 +881,9 @@ async def test_wait_for_load_state_should_work_with_clicking_target__blank(
     assert await popup.evaluate("document.readyState") == "complete"
 
 
-async def test_wait_for_load_state_should_wait_for_load_state_of_newPage(
-    context, page, server
-):
+async def test_wait_for_load_state_should_wait_for_load_state_of_new_page(
+    context: BrowserContext,
+) -> None:
     async with context.expect_page() as page_info:
         await context.new_page()
     new_page = await page_info.value
@@ -839,43 +891,43 @@ async def test_wait_for_load_state_should_wait_for_load_state_of_newPage(
     assert await new_page.evaluate("document.readyState") == "complete"
 
 
-async def test_wait_for_load_state_should_resolve_after_popup_load(context, server):
+async def test_wait_for_load_state_in_popup(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
-    # Stall the 'load' by delaying css.
     css_requests = []
-    server.set_route("/one-style.css", lambda request: css_requests.append(request))
 
-    [popup, _, _] = await asyncio.gather(
-        page.wait_for_event("popup"),
-        server.wait_for_request("/one-style.css"),
-        page.evaluate(
+    def handle_request(request: TestServerRequest) -> None:
+        css_requests.append(request)
+        request.write(b"body {}")
+        request.finish()
+
+    server.set_route("/one-style.css", handle_request)
+
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
             "url => window.popup = window.open(url)", server.PREFIX + "/one-style.html"
-        ),
-    )
+        )
 
-    resolved = []
-    load_state_task = asyncio.create_task(popup.wait_for_load_state())
-    # Round trips!
-    for _ in range(5):
-        await page.evaluate("window")
-    assert not resolved
-    css_requests[0].finish()
-    await load_state_task
-    assert popup.url == server.PREFIX + "/one-style.html"
+    popup = await popup_info.value
+    await popup.wait_for_load_state()
+    assert len(css_requests)
 
 
-async def test_go_back_should_work(page, server):
+async def test_go_back_should_work(page: Page, server: Server) -> None:
     assert await page.go_back() is None
 
     await page.goto(server.EMPTY_PAGE)
     await page.goto(server.PREFIX + "/grid.html")
 
     response = await page.go_back()
+    assert response
     assert response.ok
     assert server.EMPTY_PAGE in response.url
 
     response = await page.go_forward()
+    assert response
     assert response.ok
     assert "/grid.html" in response.url
 
@@ -883,7 +935,7 @@ async def test_go_back_should_work(page, server):
     assert response is None
 
 
-async def test_go_back_should_work_with_history_api(page, server):
+async def test_go_back_should_work_with_history_api(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.evaluate(
         """() => {
@@ -901,28 +953,45 @@ async def test_go_back_should_work_with_history_api(page, server):
     assert page.url == server.PREFIX + "/first.html"
 
 
-async def test_frame_goto_should_navigate_subframes(page, server):
+async def test_frame_goto_should_navigate_subframes(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/frames/one-frame.html")
     assert "/frames/one-frame.html" in page.frames[0].url
     assert "/frames/frame.html" in page.frames[1].url
 
     response = await page.frames[1].goto(server.EMPTY_PAGE)
+    assert response
     assert response.ok
     assert response.frame == page.frames[1]
 
 
-async def test_frame_goto_should_reject_when_frame_detaches(page, server):
+async def test_frame_goto_should_reject_when_frame_detaches(
+    page: Page, server: Server, browser_name: str
+) -> None:
     await page.goto(server.PREFIX + "/frames/one-frame.html")
 
-    await page.route("**/empty.html", lambda route, request: None)
-    navigation_task = asyncio.create_task(page.frames[1].goto(server.EMPTY_PAGE))
-    asyncio.create_task(page.eval_on_selector("iframe", "frame => frame.remove()"))
+    server.set_route("/one-style.css", lambda _: None)
+    wait_for_request_task = asyncio.create_task(
+        server.wait_for_request("/one-style.css")
+    )
+    navigation_task = asyncio.create_task(
+        page.frames[1].goto(server.PREFIX + "/one-style.html")
+    )
+    await wait_for_request_task
+
+    await page.eval_on_selector("iframe", "frame => frame.remove()")
     with pytest.raises(Error) as exc_info:
         await navigation_task
-    assert "frame was detached" in exc_info.value.message
+    if browser_name == "chromium":
+        assert "net::ERR_FAILED" in exc_info.value.message or (
+            "frame was detached" in exc_info.value.message.lower()
+        )
+    else:
+        assert "frame was detached" in exc_info.value.message.lower()
 
 
-async def test_frame_goto_should_continue_after_client_redirect(page, server):
+async def test_frame_goto_should_continue_after_client_redirect(
+    page: Page, server: Server
+) -> None:
     server.set_route("/frames/script.js", lambda _: None)
     url = server.PREFIX + "/frames/child-redirect.html"
 
@@ -935,7 +1004,7 @@ async def test_frame_goto_should_continue_after_client_redirect(page, server):
     )
 
 
-async def test_frame_wait_for_nav_should_work(page, server):
+async def test_frame_wait_for_nav_should_work(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/frames/one-frame.html")
     frame = page.frames[1]
     async with frame.expect_navigation() as response_info:
@@ -949,26 +1018,39 @@ async def test_frame_wait_for_nav_should_work(page, server):
     assert "/frames/one-frame.html" in page.url
 
 
-async def test_frame_wait_for_nav_should_fail_when_frame_detaches(page, server):
+async def test_frame_wait_for_nav_should_fail_when_frame_detaches(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/frames/one-frame.html")
     frame = page.frames[1]
     server.set_route("/empty.html", lambda _: None)
+    server.set_route("/one-style.css", lambda _: None)
     with pytest.raises(Error) as exc_info:
         async with frame.expect_navigation():
+
+            async def after_it() -> None:
+                await server.wait_for_request("/one-style.html")
+                await page.eval_on_selector(
+                    "iframe", "frame => setTimeout(() => frame.remove(), 0)"
+                )
+
             await asyncio.gather(
-                frame.evaluate('window.location = "/empty.html"'),
-                page.evaluate(
-                    'setTimeout(() => document.querySelector("iframe").remove())'
+                page.eval_on_selector(
+                    "iframe",
+                    "frame => frame.contentWindow.location.href = '/one-style.html'",
                 ),
+                after_it(),
             )
     assert "frame was detached" in exc_info.value.message
 
 
-async def test_frame_wait_for_load_state_should_work(page, server):
+async def test_frame_wait_for_load_state_should_work(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/frames/one-frame.html")
     frame = page.frames[1]
 
-    request_future = asyncio.Future()
+    request_future: "asyncio.Future[Route]" = asyncio.Future()
     await page.route(
         server.PREFIX + "/one-style.css",
         lambda route, request: request_future.set_result(route),
@@ -984,22 +1066,22 @@ async def test_frame_wait_for_load_state_should_work(page, server):
     await load_task
 
 
-async def test_reload_should_work(page, server):
+async def test_reload_should_work(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.evaluate("window._foo = 10")
     await page.reload()
     assert await page.evaluate("window._foo") is None
 
 
-async def test_reload_should_work_with_data_url(page, server):
+async def test_reload_should_work_with_data_url(page: Page, server: Server) -> None:
     await page.goto("data:text/html,hello")
     assert "hello" in await page.content()
     assert await page.reload() is None
     assert "hello" in await page.content()
 
 
-async def test_should_work_with__blank_target(page, server):
-    def handler(request):
+async def test_should_work_with__blank_target(page: Page, server: Server) -> None:
+    def handler(request: TestServerRequest) -> None:
         request.write(
             f'<a href="{server.EMPTY_PAGE}" target="_blank">Click me</a>'.encode()
         )
@@ -1011,8 +1093,10 @@ def handler(request):
     await page.click('"Click me"')
 
 
-async def test_should_work_with_cross_process__blank_target(page, server):
-    def handler(request):
+async def test_should_work_with_cross_process__blank_target(
+    page: Page, server: Server
+) -> None:
+    def handler(request: TestServerRequest) -> None:
         request.write(
             f'<a href="{server.CROSS_PROCESS_PREFIX}/empty.html" target="_blank">Click me</a>'.encode()
         )
@@ -1031,7 +1115,7 @@ def expect_ssl_error(error_message: str, browser_name: str) -> None:
         if sys.platform == "darwin":
             assert "The certificate for this server is invalid" in error_message
         elif sys.platform == "win32":
-            assert "SSL connect error" in error_message
+            assert "SSL peer certificate or SSH remote key was not OK" in error_message
         else:
             assert "Unacceptable TLS certificate" in error_message
     else:
diff --git a/tests/async/test_network.py b/tests/async/test_network.py
index 195f35512..8747956ab 100644
--- a/tests/async/test_network.py
+++ b/tests/async/test_network.py
@@ -14,25 +14,44 @@
 
 import asyncio
 import json
-from asyncio.futures import Future
-from typing import Dict, List, cast
+from asyncio import Future
+from pathlib import Path
+from typing import Dict, List, Optional, Union
 
 import pytest
+from twisted.web import http
 
-from playwright.async_api import Error, Page, Request, Response
+from playwright.async_api import Browser, Error, Page, Request, Response, Route
+from tests.server import Server, TestServerRequest
 
+from .utils import Utils
 
-async def test_request_fulfill(page, server):
-    async def handle_request(route, request):
+
+def adjust_server_headers(headers: Dict[str, str], browser_name: str) -> Dict[str, str]:
+    if browser_name != "firefox":
+        return headers
+    headers = headers.copy()
+    headers.pop("priority", None)
+    return headers
+
+
+async def test_request_fulfill(page: Page, server: Server) -> None:
+    async def handle_request(route: Route, request: Request) -> None:
+        headers = await route.request.all_headers()
+        assert headers["accept"]
         assert route.request == request
+        assert repr(route) == f"<Route request={route.request}>"
         assert "empty.html" in request.url
         assert request.headers["user-agent"]
         assert request.method == "GET"
         assert request.post_data is None
-        assert request.is_navigation_request
+        assert request.is_navigation_request()
         assert request.resource_type == "document"
         assert request.frame == page.main_frame
         assert request.frame.url == "about:blank"
+        assert (
+            repr(request) == f"<Request url={request.url!r} method={request.method!r}>"
+        )
         await route.fulfill(body="Text")
 
     await page.route(
@@ -41,16 +60,23 @@ async def handle_request(route, request):
     )
 
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
+
     assert response.ok
+    assert (
+        repr(response) == f"<Response url={response.url!r} request={response.request}>"
+    )
     assert await response.text() == "Text"
 
 
-async def test_request_continue(page, server):
-    async def handle_request(route, request, intercepted):
+async def test_request_continue(page: Page, server: Server) -> None:
+    async def handle_request(
+        route: Route, request: Request, intercepted: List[bool]
+    ) -> None:
         intercepted.append(True)
         await route.continue_()
 
-    intercepted = list()
+    intercepted: List[bool] = []
     await page.route(
         "**/*",
         lambda route, request: asyncio.create_task(
@@ -59,21 +85,40 @@ async def handle_request(route, request, intercepted):
     )
 
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.ok
     assert intercepted == [True]
     assert await page.title() == ""
 
 
 async def test_page_events_request_should_fire_for_navigation_requests(
-    page: Page, server
-):
+    page: Page, server: Server
+) -> None:
     requests = []
     page.on("request", lambda r: requests.append(r))
     await page.goto(server.EMPTY_PAGE)
     assert len(requests) == 1
 
 
-async def test_page_events_request_should_fire_for_iframes(page, server, utils):
+async def test_page_events_request_should_accept_method(
+    page: Page, server: Server
+) -> None:
+    class Log:
+        def __init__(self) -> None:
+            self.requests: List[Request] = []
+
+        def handle(self, request: Request) -> None:
+            self.requests.append(request)
+
+    log = Log()
+    page.on("request", log.handle)
+    await page.goto(server.EMPTY_PAGE)
+    assert len(log.requests) == 1
+
+
+async def test_page_events_request_should_fire_for_iframes(
+    page: Page, server: Server, utils: Utils
+) -> None:
     requests = []
     page.on("request", lambda r: requests.append(r))
     await page.goto(server.EMPTY_PAGE)
@@ -81,7 +126,9 @@ async def test_page_events_request_should_fire_for_iframes(page, server, utils):
     assert len(requests) == 2
 
 
-async def test_page_events_request_should_fire_for_fetches(page, server):
+async def test_page_events_request_should_fire_for_fetches(
+    page: Page, server: Server
+) -> None:
     requests = []
     page.on("request", lambda r: requests.append(r))
     await page.goto(server.EMPTY_PAGE)
@@ -90,23 +137,25 @@ async def test_page_events_request_should_fire_for_fetches(page, server):
 
 
 async def test_page_events_request_should_report_requests_and_responses_handled_by_service_worker(
-    page: Page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/serviceworkers/fetchdummy/sw.html")
     await page.evaluate("() => window.activationPromise")
-    [request, sw_response] = await asyncio.gather(
-        page.wait_for_event("request"), page.evaluate('() => fetchDummy("foo")')
-    )
+    sw_response = None
+    async with page.expect_request("**/*") as request_info:
+        sw_response = await page.evaluate('() => fetchDummy("foo")')
+    request = await request_info.value
     assert sw_response == "responseFromServiceWorker:foo"
     assert request.url == server.PREFIX + "/serviceworkers/fetchdummy/foo"
     response = await request.response()
+    assert response
     assert response.url == server.PREFIX + "/serviceworkers/fetchdummy/foo"
     assert await response.text() == "responseFromServiceWorker:foo"
 
 
 async def test_request_frame_should_work_for_main_frame_navigation_request(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     requests = []
     page.on("request", lambda r: requests.append(r))
     await page.goto(server.EMPTY_PAGE)
@@ -115,8 +164,8 @@ async def test_request_frame_should_work_for_main_frame_navigation_request(
 
 
 async def test_request_frame_should_work_for_subframe_navigation_request(
-    page, server, utils
-):
+    page: Page, server: Server, utils: Utils
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     requests = []
     page.on("request", lambda r: requests.append(r))
@@ -125,7 +174,9 @@ async def test_request_frame_should_work_for_subframe_navigation_request(
     assert requests[0].frame == page.frames[1]
 
 
-async def test_request_frame_should_work_for_fetch_requests(page, server):
+async def test_request_frame_should_work_for_fetch_requests(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     requests: List[Request] = []
     page.on("request", lambda r: requests.append(r))
@@ -136,9 +187,10 @@ async def test_request_frame_should_work_for_fetch_requests(page, server):
 
 
 async def test_request_headers_should_work(
-    page, server, is_chromium, is_firefox, is_webkit
-):
+    page: Page, server: Server, is_chromium: bool, is_firefox: bool, is_webkit: bool
+) -> None:
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     if is_chromium:
         assert "Chrome" in response.request.headers["user-agent"]
     elif is_firefox:
@@ -148,11 +200,17 @@ async def test_request_headers_should_work(
 
 
 async def test_request_headers_should_get_the_same_headers_as_the_server(
-    page: Page, server, is_webkit, is_win
-):
+    page: Page,
+    server: Server,
+    is_webkit: bool,
+    is_win: bool,
+    browser_name: str,
+) -> None:
+    if is_webkit and is_win:
+        pytest.xfail("Curl does not show accept-encoding and accept-language")
     server_request_headers_future: Future[Dict[str, str]] = asyncio.Future()
 
-    def handle(request):
+    def handle(request: http.Request) -> None:
         normalized_headers = {
             key.decode().lower(): value[0].decode()
             for key, value in request.requestHeaders.getAllRawHeaders()
@@ -163,21 +221,22 @@ def handle(request):
 
     server.set_route("/empty.html", handle)
     response = await page.goto(server.EMPTY_PAGE)
-    server_headers = await server_request_headers_future
-    if is_webkit and is_win:
-        # Curl does not show accept-encoding and accept-language
-        server_headers.pop("accept-encoding")
-        server_headers.pop("accept-language")
-    assert cast(Response, response).request.headers == server_headers
+    assert response
+    server_headers = adjust_server_headers(
+        await server_request_headers_future, browser_name
+    )
+    assert await response.request.all_headers() == server_headers
 
 
 async def test_request_headers_should_get_the_same_headers_as_the_server_cors(
-    page: Page, server, is_webkit, is_win
-):
+    page: Page, server: Server, is_webkit: bool, is_win: bool, browser_name: str
+) -> None:
+    if is_webkit and is_win:
+        pytest.xfail("Curl does not show accept-encoding and accept-language")
     await page.goto(server.PREFIX + "/empty.html")
     server_request_headers_future: Future[Dict[str, str]] = asyncio.Future()
 
-    def handle_something(request):
+    def handle_something(request: http.Request) -> None:
         normalized_headers = {
             key.decode().lower(): value[0].decode()
             for key, value in request.requestHeaders.getAllRawHeaders()
@@ -189,32 +248,130 @@ def handle_something(request):
 
     server.set_route("/something", handle_something)
 
-    requestPromise = asyncio.create_task(page.wait_for_event("request"))
-    text = await page.evaluate(
-        """async url => {
-      const data = await fetch(url);
-      return data.text();
-    }""",
-        server.CROSS_PROCESS_PREFIX + "/something",
-    )
-    request: Request = await requestPromise
+    text = None
+    async with page.expect_request("**/*") as request_info:
+        text = await page.evaluate(
+            """async url => {
+                const data = await fetch(url);
+                return data.text();
+            }""",
+            server.CROSS_PROCESS_PREFIX + "/something",
+        )
+    request = await request_info.value
     assert text == "done"
-    server_headers = await server_request_headers_future
-    if is_webkit and is_win:
-        # Curl does not show accept-encoding and accept-language
-        server_headers.pop("accept-encoding")
-        server_headers.pop("accept-language")
-    assert request.headers == server_headers
+    server_headers = adjust_server_headers(
+        await server_request_headers_future, browser_name
+    )
+    assert await request.all_headers() == server_headers
+
+
+async def test_should_report_request_headers_array(
+    page: Page, server: Server, is_win: bool, browser_name: str
+) -> None:
+    if is_win and browser_name == "webkit":
+        pytest.skip("libcurl does not support non-set-cookie multivalue headers")
+    expected_headers = []
+
+    def handle(request: http.Request) -> None:
+        for name, values in request.requestHeaders.getAllRawHeaders():
+            for value in values:
+                if browser_name == "firefox" and name.decode().lower() == "priority":
+                    continue
+                expected_headers.append(
+                    {"name": name.decode().lower(), "value": value.decode()}
+                )
+        request.finish()
 
+    server.set_route("/headers", handle)
+    await page.goto(server.EMPTY_PAGE)
+    async with page.expect_request("*/**") as request_info:
+        await page.evaluate(
+            """() => fetch('/headers', {
+            headers: [
+                ['header-a', 'value-a'],
+                ['header-b', 'value-b'],
+                ['header-a', 'value-a-1'],
+                ['header-a', 'value-a-2'],
+            ]
+            })
+        """
+        )
+    request = await request_info.value
+    sorted_pw_request_headers = sorted(
+        list(
+            map(
+                lambda header: {
+                    "name": header["name"].lower(),
+                    "value": header["value"],
+                },
+                await request.headers_array(),
+            )
+        ),
+        key=lambda header: header["name"],
+    )
+    sorted_expected_headers = sorted(
+        expected_headers, key=lambda header: header["name"]
+    )
+    assert sorted_pw_request_headers == sorted_expected_headers
+    assert await request.header_value("Header-A") == "value-a, value-a-1, value-a-2"
+    assert await request.header_value("not-there") is None
+
+
+async def test_should_report_response_headers_array(
+    page: Page, server: Server, is_win: bool, browser_name: str
+) -> None:
+    if is_win and browser_name == "webkit":
+        pytest.skip("libcurl does not support non-set-cookie multivalue headers")
+    expected_headers = {
+        "header-a": ["value-a", "value-a-1", "value-a-2"],
+        "header-b": ["value-b"],
+        "set-cookie": ["a=b", "c=d"],
+    }
+
+    def handle(request: http.Request) -> None:
+        for key in expected_headers:
+            for value in expected_headers[key]:
+                request.responseHeaders.addRawHeader(key, value)
+        request.finish()
 
-async def test_response_headers_should_work(page, server):
+    server.set_route("/headers", handle)
+    await page.goto(server.EMPTY_PAGE)
+    async with page.expect_response("*/**") as response_info:
+        await page.evaluate(
+            """() => fetch('/headers')
+        """
+        )
+    response = await response_info.value
+    actual_headers: Dict[str, List[str]] = {}
+    for header in await response.headers_array():
+        name = header["name"].lower()
+        value = header["value"]
+        if not actual_headers.get(name):
+            actual_headers[name] = []
+        actual_headers[name].append(value)
+
+    for key in ["Keep-Alive", "Connection", "Date", "Transfer-Encoding"]:
+        if key in actual_headers:
+            actual_headers.pop(key)
+        if key.lower() in actual_headers:
+            actual_headers.pop(key.lower())
+    assert actual_headers == expected_headers
+    assert await response.header_value("not-there") is None
+    assert await response.header_value("set-cookie") == "a=b\nc=d"
+    assert await response.header_value("header-a") == "value-a, value-a-1, value-a-2"
+    assert await response.header_values("set-cookie") == ["a=b", "c=d"]
+
+
+async def test_response_headers_should_work(page: Page, server: Server) -> None:
     server.set_route("/empty.html", lambda r: (r.setHeader("foo", "bar"), r.finish()))
 
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.headers["foo"] == "bar"
+    assert (await response.all_headers())["foo"] == "bar"
 
 
-async def test_request_post_data_should_work(page, server):
+async def test_request_post_data_should_work(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     server.set_route("/post", lambda r: r.finish())
     requests = []
@@ -227,13 +384,14 @@ async def test_request_post_data_should_work(page, server):
 
 
 async def test_request_post_data__should_be_undefined_when_there_is_no_post_data(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.request.post_data is None
 
 
-async def test_should_parse_the_json_post_data(page, server):
+async def test_should_parse_the_json_post_data(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     server.set_route("/post", lambda req: req.finish())
     requests = []
@@ -245,7 +403,9 @@ async def test_should_parse_the_json_post_data(page, server):
     assert requests[0].post_data_json == {"foo": "bar"}
 
 
-async def test_should_parse_the_data_if_content_type_is_form_urlencoded(page, server):
+async def test_should_parse_the_data_if_content_type_is_form_urlencoded(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     server.set_route("/post", lambda req: req.finish())
     requests = []
@@ -258,12 +418,57 @@ async def test_should_parse_the_data_if_content_type_is_form_urlencoded(page, se
     assert requests[0].post_data_json == {"foo": "bar", "baz": "123"}
 
 
-async def test_should_be_undefined_when_there_is_no_post_data(page, server):
+async def test_should_be_undefined_when_there_is_no_post_data(
+    page: Page, server: Server
+) -> None:
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.request.post_data_json is None
 
 
-async def test_should_work_with_binary_post_data(page, server):
+async def test_should_return_post_data_without_content_type(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    async with page.expect_request("**/*") as request_info:
+        await page.evaluate(
+            """({url}) => {
+            const request = new Request(url, {
+                method: 'POST',
+                body: JSON.stringify({ value: 42 }),
+            });
+            request.headers.set('content-type', '');
+            return fetch(request);
+        }""",
+            {"url": server.PREFIX + "/title.html"},
+        )
+    request = await request_info.value
+    assert request.post_data_json == {"value": 42}
+
+
+async def test_should_throw_on_invalid_json_in_post_data(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    async with page.expect_request("**/*") as request_info:
+        await page.evaluate(
+            """({url}) => {
+            const request = new Request(url, {
+                method: 'POST',
+                body: '<not a json>',
+            });
+            request.headers.set('content-type', '');
+            return fetch(request);
+        }""",
+            {"url": server.PREFIX + "/title.html"},
+        )
+    request = await request_info.value
+    with pytest.raises(Error) as exc_info:
+        print(request.post_data_json)
+    assert "POST data is not a valid JSON object: <not a json>" in str(exc_info.value)
+
+
+async def test_should_work_with_binary_post_data(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     server.set_route("/post", lambda req: req.finish())
     requests = []
@@ -280,7 +485,9 @@ async def test_should_work_with_binary_post_data(page, server):
         assert buffer[i] == i
 
 
-async def test_should_work_with_binary_post_data_and_interception(page, server):
+async def test_should_work_with_binary_post_data_and_interception(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     server.set_route("/post", lambda req: req.finish())
     requests = []
@@ -298,42 +505,53 @@ async def test_should_work_with_binary_post_data_and_interception(page, server):
         assert buffer[i] == i
 
 
-async def test_response_text_should_work(page, server):
+async def test_response_text_should_work(page: Page, server: Server) -> None:
     response = await page.goto(server.PREFIX + "/simple.json")
+    assert response
     assert await response.text() == '{"foo": "bar"}\n'
 
 
-async def test_response_text_should_return_uncompressed_text(page, server):
+async def test_response_text_should_return_uncompressed_text(
+    page: Page, server: Server
+) -> None:
     server.enable_gzip("/simple.json")
     response = await page.goto(server.PREFIX + "/simple.json")
+    assert response
     assert response.headers["content-encoding"] == "gzip"
     assert await response.text() == '{"foo": "bar"}\n'
 
 
 async def test_response_text_should_throw_when_requesting_body_of_redirected_response(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     server.set_redirect("/foo.html", "/empty.html")
     response = await page.goto(server.PREFIX + "/foo.html")
+    assert response
     redirected_from = response.request.redirected_from
     assert redirected_from
     redirected = await redirected_from.response()
+    assert redirected
     assert redirected.status == 302
-    error = None
+    error: Optional[Error] = None
     try:
         await redirected.text()
     except Error as exc:
         error = exc
+    assert error
     assert "Response body is unavailable for redirect responses" in error.message
 
 
-async def test_response_json_should_work(page, server):
+async def test_response_json_should_work(page: Page, server: Server) -> None:
     response = await page.goto(server.PREFIX + "/simple.json")
+    assert response
     assert await response.json() == {"foo": "bar"}
 
 
-async def test_response_body_should_work(page, server, assetdir):
+async def test_response_body_should_work(
+    page: Page, server: Server, assetdir: Path
+) -> None:
     response = await page.goto(server.PREFIX + "/pptr.png")
+    assert response
     with open(
         assetdir / "pptr.png",
         "rb",
@@ -341,9 +559,12 @@ async def test_response_body_should_work(page, server, assetdir):
         assert fd.read() == await response.body()
 
 
-async def test_response_body_should_work_with_compression(page, server, assetdir):
+async def test_response_body_should_work_with_compression(
+    page: Page, server: Server, assetdir: Path
+) -> None:
     server.enable_gzip("/pptr.png")
     response = await page.goto(server.PREFIX + "/pptr.png")
+    assert response
     with open(
         assetdir / "pptr.png",
         "rb",
@@ -351,14 +572,17 @@ async def test_response_body_should_work_with_compression(page, server, assetdir
         assert fd.read() == await response.body()
 
 
-async def test_response_status_text_should_work(page, server):
+async def test_response_status_text_should_work(page: Page, server: Server) -> None:
     server.set_route("/cool", lambda r: (r.setResponseCode(200, b"cool!"), r.finish()))
 
     response = await page.goto(server.PREFIX + "/cool")
+    assert response
     assert response.status_text == "cool!"
 
 
-async def test_request_resource_type_should_return_event_source(page, server):
+async def test_request_resource_type_should_return_event_source(
+    page: Page, server: Server
+) -> None:
     SSE_MESSAGE = {"foo": "bar"}
     # 1. Setup server-sent events on server that immediately sends a message to the client.
     server.set_route(
@@ -392,7 +616,7 @@ async def test_request_resource_type_should_return_event_source(page, server):
     assert requests[0].resource_type == "eventsource"
 
 
-async def test_network_events_request(page, server):
+async def test_network_events_request(page: Page, server: Server) -> None:
     requests = []
     page.on("request", lambda r: requests.append(r))
     await page.goto(server.EMPTY_PAGE)
@@ -405,7 +629,7 @@ async def test_network_events_request(page, server):
     assert requests[0].frame.url == server.EMPTY_PAGE
 
 
-async def test_network_events_response(page, server):
+async def test_network_events_response(page: Page, server: Server) -> None:
     responses = []
     page.on("response", lambda r: responses.append(r))
     await page.goto(server.EMPTY_PAGE)
@@ -417,18 +641,24 @@ async def test_network_events_response(page, server):
 
 
 async def test_network_events_request_failed(
-    page, server, is_chromium, is_webkit, is_mac, is_win
-):
-    def handle_request(request):
+    page: Page,
+    server: Server,
+    is_chromium: bool,
+    is_webkit: bool,
+    is_mac: bool,
+    is_win: bool,
+) -> None:
+    def handle_request(request: TestServerRequest) -> None:
         request.setHeader("Content-Type", "text/css")
-        request.transport.loseConnection()
+        request.loseConnection()
 
     server.set_route("/one-style.css", handle_request)
 
     failed_requests = []
     page.on("requestfailed", lambda request: failed_requests.append(request))
     await page.goto(server.PREFIX + "/one-style.html")
-    assert len(failed_requests) == 1
+    # TODO: https://github.com/microsoft/playwright/issues/12789
+    assert len(failed_requests) >= 1
     assert "one-style.css" in failed_requests[0].url
     assert await failed_requests[0].response() is None
     assert failed_requests[0].resource_type == "stylesheet"
@@ -443,89 +673,108 @@ def handle_request(request):
                 == "Server returned nothing (no headers, no data)"
             )
         else:
-            assert failed_requests[0].failure == "Message Corrupt"
+            assert failed_requests[0].failure in [
+                "Message Corrupt",
+                "Connection terminated unexpectedly",
+            ]
     else:
         assert failed_requests[0].failure == "NS_ERROR_NET_RESET"
     assert failed_requests[0].frame
 
 
-async def test_network_events_request_finished(page, server):
-    response = (
-        await asyncio.gather(
-            page.goto(server.EMPTY_PAGE), page.wait_for_event("requestfinished")
-        )
-    )[0]
-    request = response.request
+async def test_network_events_request_finished(page: Page, server: Server) -> None:
+    async with page.expect_event("requestfinished") as event_info:
+        await page.goto(server.EMPTY_PAGE)
+    request = await event_info.value
     assert request.url == server.EMPTY_PAGE
     assert await request.response()
     assert request.frame == page.main_frame
     assert request.frame.url == server.EMPTY_PAGE
 
 
-async def test_network_events_should_fire_events_in_proper_order(page, server):
+async def test_network_events_should_fire_events_in_proper_order(
+    page: Page, server: Server
+) -> None:
     events = []
     page.on("request", lambda request: events.append("request"))
     page.on("response", lambda response: events.append("response"))
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     await response.finished()
     events.append("requestfinished")
     assert events == ["request", "response", "requestfinished"]
 
 
-async def test_network_events_should_support_redirects(page, server):
-    events = []
-    page.on("request", lambda request: events.append(f"{request.method} {request.url}"))
-    page.on(
-        "response", lambda response: events.append(f"{response.status} {response.url}")
-    )
-    page.on("requestfinished", lambda request: events.append(f"DONE {request.url}"))
-    page.on("requestfailed", lambda request: events.append(f"FAIL {request.url}"))
-    server.set_redirect("/foo.html", "/empty.html")
+async def test_network_events_should_support_redirects(
+    page: Page, server: Server
+) -> None:
     FOO_URL = server.PREFIX + "/foo.html"
+    events: Dict[str, List[Union[str, int]]] = {}
+    events[FOO_URL] = []
+    events[server.EMPTY_PAGE] = []
+
+    def _handle_on_request(request: Request) -> None:
+        events[request.url].append(request.method)
+
+    page.on("request", _handle_on_request)
+
+    def _handle_on_response(response: Response) -> None:
+        events[response.url].append(response.status)
+
+    page.on("response", _handle_on_response)
+
+    def _handle_on_requestfinished(request: Request) -> None:
+        events[request.url].append("DONE")
+
+    page.on("requestfinished", _handle_on_requestfinished)
+
+    def _handle_on_requestfailed(request: Request) -> None:
+        events[request.url].append("FAIL")
+
+    page.on("requestfailed", _handle_on_requestfailed)
+    server.set_redirect("/foo.html", "/empty.html")
     response = await page.goto(FOO_URL)
+    assert response
     await response.finished()
-    assert events == [
-        f"GET {FOO_URL}",
-        f"302 {FOO_URL}",
-        f"DONE {FOO_URL}",
-        f"GET {server.EMPTY_PAGE}",
-        f"200 {server.EMPTY_PAGE}",
-        f"DONE {server.EMPTY_PAGE}",
-    ]
+    expected = {}
+    expected[FOO_URL] = ["GET", 302, "DONE"]
+    expected[server.EMPTY_PAGE] = ["GET", 200, "DONE"]
+    assert events == expected
     redirected_from = response.request.redirected_from
+    assert redirected_from
     assert "/foo.html" in redirected_from.url
     assert redirected_from.redirected_from is None
     assert redirected_from.redirected_to == response.request
 
 
-async def test_request_is_navigation_request_should_work(page, server):
-    pytest.skip(msg="test")
-    requests = {}
+async def test_request_is_navigation_request_should_work(
+    page: Page, server: Server
+) -> None:
+    requests: Dict[str, Request] = {}
 
-    def handle_request(request):
-        requests[request.url().split("/").pop()] = request
+    def handle_request(request: Request) -> None:
+        requests[request.url.split("/").pop()] = request
 
     page.on("request", handle_request)
     server.set_redirect("/rrredirect", "/frames/one-frame.html")
     await page.goto(server.PREFIX + "/rrredirect")
-    print("kek")
-    assert requests.get("rrredirect").is_navigation_request
-    assert requests.get("one-frame.html").is_navigation_request
-    assert requests.get("frame.html").is_navigation_request
-    assert requests.get("script.js").is_navigation_request is False
-    assert requests.get("style.css").is_navigation_request is False
+    assert requests["rrredirect"].is_navigation_request()
+    assert requests["one-frame.html"].is_navigation_request()
+    assert requests["frame.html"].is_navigation_request()
+    assert requests["script.js"].is_navigation_request() is False
+    assert requests["style.css"].is_navigation_request() is False
 
 
 async def test_request_is_navigation_request_should_work_when_navigating_to_image(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     requests = []
     page.on("request", lambda r: requests.append(r))
     await page.goto(server.PREFIX + "/pptr.png")
-    assert requests[0].is_navigation_request
+    assert requests[0].is_navigation_request()
 
 
-async def test_set_extra_http_headers_should_work(page, server):
+async def test_set_extra_http_headers_should_work(page: Page, server: Server) -> None:
     await page.set_extra_http_headers({"foo": "bar"})
 
     request = (
@@ -537,7 +786,9 @@ async def test_set_extra_http_headers_should_work(page, server):
     assert request.getHeader("foo") == "bar"
 
 
-async def test_set_extra_http_headers_should_work_with_redirects(page, server):
+async def test_set_extra_http_headers_should_work_with_redirects(
+    page: Page, server: Server
+) -> None:
     server.set_redirect("/foo.html", "/empty.html")
     await page.set_extra_http_headers({"foo": "bar"})
 
@@ -551,8 +802,8 @@ async def test_set_extra_http_headers_should_work_with_redirects(page, server):
 
 
 async def test_set_extra_http_headers_should_work_with_extra_headers_from_browser_context(
-    browser, server
-):
+    browser: Browser, server: Server
+) -> None:
     context = await browser.new_context()
     await context.set_extra_http_headers({"foo": "bar"})
 
@@ -568,8 +819,8 @@ async def test_set_extra_http_headers_should_work_with_extra_headers_from_browse
 
 
 async def test_set_extra_http_headers_should_override_extra_headers_from_browser_context(
-    browser, server
-):
+    browser: Browser, server: Server
+) -> None:
     context = await browser.new_context(extra_http_headers={"fOo": "bAr", "baR": "foO"})
 
     page = await context.new_page()
@@ -587,11 +838,85 @@ async def test_set_extra_http_headers_should_override_extra_headers_from_browser
 
 
 async def test_set_extra_http_headers_should_throw_for_non_string_header_values(
-    page, server
-):
-    error = None
+    page: Page,
+) -> None:
+    error: Optional[Error] = None
     try:
-        await page.set_extra_http_headers({"foo": 1})
+        await page.set_extra_http_headers({"foo": 1})  # type: ignore
     except Error as exc:
         error = exc
-    assert error.message == "headers[0].value: expected string, got number"
+    assert error
+    assert (
+        error.message
+        == "Page.set_extra_http_headers: headers[0].value: expected string, got number"
+    )
+
+
+async def test_response_server_addr(page: Page, server: Server) -> None:
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    server_addr = await response.server_addr()
+    assert server_addr
+    assert server_addr["port"] == server.PORT
+    assert server_addr["ipAddress"] in ["127.0.0.1", "[::1]"]
+
+
+async def test_response_security_details(
+    browser: Browser,
+    https_server: Server,
+    browser_name: str,
+    is_win: bool,
+    is_linux: bool,
+) -> None:
+    if (browser_name == "webkit" and is_linux) or (browser_name == "webkit" and is_win):
+        pytest.skip("https://github.com/microsoft/playwright/issues/6759")
+    page = await browser.new_page(ignore_https_errors=True)
+    response = await page.goto(https_server.EMPTY_PAGE)
+    assert response
+    await response.finished()
+    security_details = await response.security_details()
+    assert security_details
+    if browser_name == "webkit" and is_win:
+        assert security_details == {
+            "subjectName": "puppeteer-tests",
+            "validFrom": 1550084863,
+            "validTo": -1,
+        }
+    elif browser_name == "webkit":
+        assert security_details == {
+            "protocol": "TLS 1.3",
+            "subjectName": "puppeteer-tests",
+            "validFrom": 1550084863,
+            "validTo": 33086084863,
+        }
+    else:
+        assert security_details == {
+            "issuer": "puppeteer-tests",
+            "protocol": "TLS 1.3",
+            "subjectName": "puppeteer-tests",
+            "validFrom": 1550084863,
+            "validTo": 33086084863,
+        }
+    await page.close()
+
+
+async def test_response_security_details_none_without_https(
+    page: Page, server: Server
+) -> None:
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    security_details = await response.security_details()
+    assert security_details is None
+
+
+async def test_should_report_if_request_was_from_service_worker(
+    page: Page, server: Server
+) -> None:
+    response = await page.goto(server.PREFIX + "/serviceworkers/fetch/sw.html")
+    assert response
+    assert not response.from_service_worker
+    await page.evaluate("() => window.activationPromise")
+    async with page.expect_response("**/example.txt") as response_info:
+        await page.evaluate("() => fetch('/example.txt')")
+    response = await response_info.value
+    assert response.from_service_worker
diff --git a/tests/async/test_page.py b/tests/async/test_page.py
index c977b645b..538b5f180 100644
--- a/tests/async/test_page.py
+++ b/tests/async/test_page.py
@@ -15,22 +15,34 @@
 import asyncio
 import os
 import re
+from pathlib import Path
+from typing import Any, Dict, Optional
 
 import pytest
 
-from playwright.async_api import Error, TimeoutError
+from playwright.async_api import (
+    BrowserContext,
+    Error,
+    Page,
+    Route,
+    TimeoutError,
+)
+from tests.server import Server, TestServerRequest
+from tests.utils import TARGET_CLOSED_ERROR_MESSAGE, must
 
 
-async def test_close_should_reject_all_promises(context):
+async def test_close_should_reject_all_promises(context: BrowserContext) -> None:
     new_page = await context.new_page()
     with pytest.raises(Error) as exc_info:
         await asyncio.gather(
             new_page.evaluate("() => new Promise(r => {})"), new_page.close()
         )
-    assert "Protocol error" in exc_info.value.message
+    assert " closed" in exc_info.value.message
 
 
-async def test_closed_should_not_visible_in_context_pages(context):
+async def test_closed_should_not_visible_in_context_pages(
+    context: BrowserContext,
+) -> None:
     page = await context.new_page()
     assert page in context.pages
     await page.close()
@@ -38,15 +50,18 @@ async def test_closed_should_not_visible_in_context_pages(context):
 
 
 async def test_close_should_run_beforeunload_if_asked_for(
-    context, server, is_chromium, is_webkit
-):
+    context: BrowserContext, server: Server, is_chromium: bool, is_webkit: bool
+) -> None:
     page = await context.new_page()
     await page.goto(server.PREFIX + "/beforeunload.html")
     # We have to interact with a page so that 'beforeunload' handlers
     # fire.
     await page.click("body")
-    page_closing_future = asyncio.create_task(page.close(run_before_unload=True))
-    dialog = await page.wait_for_event("dialog")
+
+    async with page.expect_event("dialog") as dialog_info:
+        await page.close(run_before_unload=True)
+    dialog = await dialog_info.value
+
     assert dialog.type == "beforeunload"
     assert dialog.default_value == ""
     if is_chromium:
@@ -55,14 +70,16 @@ async def test_close_should_run_beforeunload_if_asked_for(
         assert dialog.message == "Leave?"
     else:
         assert (
-            dialog.message
-            == "This page is asking you to confirm that you want to leave - data you have entered may not be saved."
+            "This page is asking you to confirm that you want to leave"
+            in dialog.message
         )
-    await dialog.accept()
-    await page_closing_future
+    async with page.expect_event("close"):
+        await dialog.accept()
 
 
-async def test_close_should_not_run_beforeunload_by_default(context, server):
+async def test_close_should_not_run_beforeunload_by_default(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.PREFIX + "/beforeunload.html")
     # We have to interact with a page so that 'beforeunload' handlers
@@ -71,38 +88,51 @@ async def test_close_should_not_run_beforeunload_by_default(context, server):
     await page.close()
 
 
-async def test_close_should_set_the_page_close_state(context):
+async def test_should_be_able_to_navigate_away_from_page_with_before_unload(
+    server: Server, page: Page
+) -> None:
+    await page.goto(server.PREFIX + "/beforeunload.html")
+    # We have to interact with a page so that 'beforeunload' handlers
+    # fire.
+    await page.click("body")
+    await page.goto(server.EMPTY_PAGE)
+
+
+async def test_close_should_set_the_page_close_state(context: BrowserContext) -> None:
     page = await context.new_page()
     assert page.is_closed() is False
     await page.close()
     assert page.is_closed()
 
 
-async def test_close_should_terminate_network_waiters(context, server):
+async def test_close_should_terminate_network_waiters(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
 
-    async def wait_for_request():
-        try:
-            await page.wait_for_request(server.EMPTY_PAGE)
-        except Error as e:
-            return e
+    async def wait_for_request() -> Error:
+        with pytest.raises(Error) as exc_info:
+            async with page.expect_request(server.EMPTY_PAGE):
+                pass
+        return exc_info.value
 
-    async def wait_for_response():
-        try:
-            await page.wait_for_response(server.EMPTY_PAGE)
-        except Error as e:
-            return e
+    async def wait_for_response() -> Error:
+        with pytest.raises(Error) as exc_info:
+            async with page.expect_response(server.EMPTY_PAGE):
+                pass
+        return exc_info.value
 
     results = await asyncio.gather(
         wait_for_request(), wait_for_response(), page.close()
     )
     for i in range(2):
         error = results[i]
-        assert "Page closed" in error.message
+        assert error
+        assert TARGET_CLOSED_ERROR_MESSAGE in error.message
         assert "Timeout" not in error.message
 
 
-async def test_close_should_be_callable_twice(context):
+async def test_close_should_be_callable_twice(context: BrowserContext) -> None:
     page = await context.new_page()
     await asyncio.gather(
         page.close(),
@@ -111,192 +141,304 @@ async def test_close_should_be_callable_twice(context):
     await page.close()
 
 
-async def test_load_should_fire_when_expected(page):
+async def test_load_should_fire_when_expected(page: Page) -> None:
+    async with page.expect_event("load"):
+        await page.goto("about:blank")
+
+
+@pytest.mark.skip("FIXME")
+async def test_should_work_with_wait_for_loadstate(page: Page, server: Server) -> None:
+    messages = []
+
+    def _handler(request: TestServerRequest) -> None:
+        messages.append("route")
+        request.setHeader("Content-Type", "text/html")
+        request.write(b"<link rel='stylesheet' href='./one-style.css'>")
+        request.finish()
+
+    server.set_route(
+        "/empty.html",
+        _handler,
+    )
+
+    await page.set_content(f'<a id="anchor" href="{server.EMPTY_PAGE}">empty.html</a>')
+
+    async def wait_for_clickload() -> None:
+        await page.click("a")
+        await page.wait_for_load_state("load")
+        messages.append("clickload")
+
+    async def wait_for_page_load() -> None:
+        await page.wait_for_event("load")
+        messages.append("load")
+
     await asyncio.gather(
-        page.goto("about:blank"),
-        page.wait_for_event("load"),
+        wait_for_clickload(),
+        wait_for_page_load(),
     )
 
+    assert messages == ["route", "load", "clickload"]
+
 
-async def test_async_stacks_should_work(page, server):
+async def test_async_stacks_should_work(page: Page, server: Server) -> None:
     await page.route(
         "**/empty.html", lambda route, response: asyncio.create_task(route.abort())
     )
     with pytest.raises(Error) as exc_info:
         await page.goto(server.EMPTY_PAGE)
+    assert exc_info.value.stack
     assert __file__ in exc_info.value.stack
 
 
-# TODO: bring in page.crash events
-
-
-async def test_opener_should_provide_access_to_the_opener_page(page):
-    [popup, _] = await asyncio.gather(
-        page.wait_for_event("popup"),
-        page.evaluate("window.open('about:blank')"),
-    )
+async def test_opener_should_provide_access_to_the_opener_page(page: Page) -> None:
+    async with page.expect_popup() as popup_info:
+        await page.evaluate("window.open('about:blank')")
+    popup = await popup_info.value
     opener = await popup.opener()
     assert opener == page
 
 
-async def test_opener_should_return_null_if_parent_page_has_been_closed(page):
-    [popup, _] = await asyncio.gather(
-        page.wait_for_event("popup"),
-        page.evaluate("window.open('about:blank')"),
-    )
+async def test_opener_should_return_null_if_parent_page_has_been_closed(
+    page: Page,
+) -> None:
+    async with page.expect_popup() as popup_info:
+        await page.evaluate("window.open('about:blank')")
+    popup = await popup_info.value
     await page.close()
     opener = await popup.opener()
     assert opener is None
 
 
-async def test_domcontentloaded_should_fire_when_expected(page, server):
+async def test_domcontentloaded_should_fire_when_expected(
+    page: Page, server: Server
+) -> None:
     future = asyncio.create_task(page.goto("about:blank"))
-    await page.wait_for_event("domcontentloaded")
+    async with page.expect_event("domcontentloaded"):
+        pass
     await future
 
 
-async def test_wait_for_request(page, server):
+async def test_wait_for_request(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
-    [request, _] = await asyncio.gather(
-        page.wait_for_request(server.PREFIX + "/digits/2.png"),
-        page.evaluate(
+    async with page.expect_request(server.PREFIX + "/digits/2.png") as request_info:
+        await page.evaluate(
             """() => {
                 fetch('/digits/1.png')
                 fetch('/digits/2.png')
                 fetch('/digits/3.png')
             }"""
-        ),
-    )
+        )
+    request = await request_info.value
     assert request.url == server.PREFIX + "/digits/2.png"
 
 
-async def test_wait_for_request_should_work_with_predicate(page, server):
+async def test_wait_for_request_should_work_with_predicate(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
-    [request, _] = await asyncio.gather(
-        page.wait_for_event(
-            "request", lambda request: request.url == server.PREFIX + "/digits/2.png"
-        ),
-        page.evaluate(
+    async with page.expect_request(
+        lambda request: request.url == server.PREFIX + "/digits/2.png"
+    ) as request_info:
+        await page.evaluate(
             """() => {
                 fetch('/digits/1.png')
                 fetch('/digits/2.png')
                 fetch('/digits/3.png')
             }"""
-        ),
-    )
+        )
+    request = await request_info.value
     assert request.url == server.PREFIX + "/digits/2.png"
 
 
-async def test_wait_for_request_should_timeout(page, server):
+async def test_wait_for_request_should_timeout(page: Page, server: Server) -> None:
     with pytest.raises(Error) as exc_info:
-        await page.wait_for_event("request", timeout=1)
+        async with page.expect_event("request", timeout=1):
+            pass
     assert exc_info.type is TimeoutError
 
 
-async def test_wait_for_request_should_respect_default_timeout(page, server):
+async def test_wait_for_request_should_respect_default_timeout(
+    page: Page, server: Server
+) -> None:
     page.set_default_timeout(1)
     with pytest.raises(Error) as exc_info:
-        await page.wait_for_event("request", lambda _: False)
+        async with page.expect_event("request", lambda _: False):
+            pass
     assert exc_info.type is TimeoutError
 
 
-async def test_wait_for_request_should_work_with_no_timeout(page, server):
+async def test_wait_for_request_should_work_with_no_timeout(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
-    [request, _] = await asyncio.gather(
-        page.wait_for_request(server.PREFIX + "/digits/2.png", timeout=0),
-        page.evaluate(
+    async with page.expect_request(
+        server.PREFIX + "/digits/2.png", timeout=0
+    ) as request_info:
+        await page.evaluate(
             """() => setTimeout(() => {
                 fetch('/digits/1.png')
                 fetch('/digits/2.png')
                 fetch('/digits/3.png')
             }, 50)"""
-        ),
-    )
+        )
+    request = await request_info.value
     assert request.url == server.PREFIX + "/digits/2.png"
 
 
-async def test_wait_for_request_should_work_with_url_match(page, server):
+async def test_wait_for_request_should_work_with_url_match(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
-    [request, _] = await asyncio.gather(
-        page.wait_for_request(re.compile(r"digits\/\d\.png")),
-        page.evaluate("fetch('/digits/1.png')"),
-    )
+    async with page.expect_request(re.compile(r"digits\/\d\.png")) as request_info:
+        await page.evaluate("fetch('/digits/1.png')")
+    request = await request_info.value
     assert request.url == server.PREFIX + "/digits/1.png"
 
 
-async def test_wait_for_event_should_fail_with_error_upon_disconnect(page):
-    future = asyncio.create_task(page.wait_for_event("download"))
-    await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
-    await page.close()
+async def test_wait_for_event_should_fail_with_error_upon_disconnect(
+    page: Page,
+) -> None:
     with pytest.raises(Error) as exc_info:
-        await future
-    assert "Page closed" in exc_info.value.message
+        async with page.expect_download():
+            await page.close()
+    assert TARGET_CLOSED_ERROR_MESSAGE in exc_info.value.message
 
 
-async def test_wait_for_response_should_work(page, server):
+async def test_wait_for_response_should_work(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
-    [response, _] = await asyncio.gather(
-        page.wait_for_response(server.PREFIX + "/digits/2.png"),
-        page.evaluate(
+    async with page.expect_response(server.PREFIX + "/digits/2.png") as response_info:
+        await page.evaluate(
             """() => {
                 fetch('/digits/1.png')
                 fetch('/digits/2.png')
                 fetch('/digits/3.png')
             }"""
-        ),
-    )
+        )
+    response = await response_info.value
     assert response.url == server.PREFIX + "/digits/2.png"
 
 
-async def test_wait_for_response_should_respect_timeout(page, server):
+async def test_wait_for_response_should_respect_timeout(page: Page) -> None:
     with pytest.raises(Error) as exc_info:
-        await page.wait_for_event("response", timeout=1)
+        async with page.expect_response("**/*", timeout=1):
+            pass
     assert exc_info.type is TimeoutError
 
 
-async def test_wait_for_response_should_respect_default_timeout(page, server):
+async def test_wait_for_response_should_respect_default_timeout(page: Page) -> None:
     page.set_default_timeout(1)
     with pytest.raises(Error) as exc_info:
-        await page.wait_for_event("response", lambda _: False)
+        async with page.expect_response(lambda _: False):
+            pass
     assert exc_info.type is TimeoutError
 
 
-async def test_wait_for_response_should_work_with_predicate(page, server):
+async def test_wait_for_response_should_work_with_predicate(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
-    [response, _] = await asyncio.gather(
-        page.wait_for_event(
-            "response", lambda response: response.url == server.PREFIX + "/digits/2.png"
-        ),
-        page.evaluate(
+    async with page.expect_response(
+        lambda response: response.url == server.PREFIX + "/digits/2.png"
+    ) as response_info:
+        await page.evaluate(
             """() => {
                 fetch('/digits/1.png')
                 fetch('/digits/2.png')
                 fetch('/digits/3.png')
             }"""
-        ),
-    )
+        )
+    response = await response_info.value
     assert response.url == server.PREFIX + "/digits/2.png"
 
 
-async def test_wait_for_response_should_work_with_no_timeout(page, server):
+async def test_wait_for_response_should_work_with_async_predicate(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
-    [response, _] = await asyncio.gather(
-        page.wait_for_response(server.PREFIX + "/digits/2.png", timeout=0),
-        page.evaluate(
-            """() => setTimeout(() => {
+
+    async def predicate(response: Any) -> bool:
+        await asyncio.sleep(0)
+        return response.url == server.PREFIX + "/digits/2.png"
+
+    async with page.expect_response(predicate) as response_info:
+        await page.evaluate(
+            """() => {
                 fetch('/digits/1.png')
                 fetch('/digits/2.png')
                 fetch('/digits/3.png')
-            }, 50)"""
-        ),
-    )
+            }"""
+        )
+    response = await response_info.value
     assert response.url == server.PREFIX + "/digits/2.png"
 
 
-async def test_expose_binding(page):
+async def test_expect_response_should_reject_when_async_predicate_throws(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    async def predicate(response: Any) -> bool:
+        raise Exception("Async oops!")
+
+    with pytest.raises(Exception, match="Async oops!"):
+        async with page.expect_response(predicate):
+            await page.evaluate("() => fetch('/digits/1.png')")
+
+
+async def test_expect_response_should_reject_when_sync_predicate_throws(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    def predicate(response: Any) -> bool:
+        raise Exception("Sync oops!")
+
+    with pytest.raises(Exception, match="Sync oops!"):
+        async with page.expect_response(predicate):
+            await page.evaluate("() => fetch('/digits/1.png')")
+
+
+async def test_wait_for_response_should_work_with_no_timeout(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    async with page.expect_response(server.PREFIX + "/digits/2.png") as response_info:
+        await page.evaluate(
+            """() => {
+                fetch('/digits/1.png')
+                fetch('/digits/2.png')
+                fetch('/digits/3.png')
+            }"""
+        )
+    response = await response_info.value
+    assert response.url == server.PREFIX + "/digits/2.png"
+
+
+async def test_wait_for_response_should_use_context_timeout(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    context.set_default_timeout(1_000)
+    with pytest.raises(Error) as exc_info:
+        async with page.expect_response("https://playwright.dev"):
+            pass
+    assert exc_info.type is TimeoutError
+    assert "Timeout 1000ms exceeded" in exc_info.value.message
+
+
+async def test_expect_response_should_not_hang_when_predicate_throws(
+    page: Page,
+) -> None:
+    with pytest.raises(Exception, match="Oops!"):
+        async with page.expect_response("**/*"):
+            raise Exception("Oops!")
+
+
+async def test_expose_binding(page: Page) -> None:
     binding_source = []
 
-    def binding(source, a, b):
+    def binding(source: Dict, a: int, b: int) -> int:
         binding_source.append(source)
         return a + b
 
@@ -310,15 +452,16 @@ def binding(source, a, b):
     assert result == 11
 
 
-async def test_expose_function(page, server):
+async def test_expose_function(page: Page, server: Server) -> None:
     await page.expose_function("compute", lambda a, b: a * b)
     result = await page.evaluate("compute(9, 4)")
     assert result == 36
 
 
-@pytest.mark.skip("todo mxschmitt")
-async def test_expose_function_should_throw_exception_in_page_context(page, server):
-    def throw():
+async def test_expose_function_should_throw_exception_in_page_context(
+    page: Page, server: Server
+) -> None:
+    def throw() -> None:
         raise Exception("WOOF WOOF")
 
     await page.expose_function("woof", lambda: throw())
@@ -335,7 +478,9 @@ def throw():
     assert __file__ in result["stack"]
 
 
-async def test_expose_function_should_be_callable_from_inside_add_init_script(page):
+async def test_expose_function_should_be_callable_from_inside_add_init_script(
+    page: Page,
+) -> None:
     called = []
     await page.expose_function("woof", lambda: called.append(True))
     await page.add_init_script("woof()")
@@ -343,136 +488,169 @@ async def test_expose_function_should_be_callable_from_inside_add_init_script(pa
     assert called == [True]
 
 
-async def test_expose_function_should_survive_navigation(page, server):
+async def test_expose_function_should_survive_navigation(
+    page: Page, server: Server
+) -> None:
     await page.expose_function("compute", lambda a, b: a * b)
     await page.goto(server.EMPTY_PAGE)
     result = await page.evaluate("compute(9, 4)")
     assert result == 36
 
 
-async def test_expose_function_should_await_returned_promise(page):
-    async def mul(a, b):
+async def test_expose_function_should_await_returned_promise(page: Page) -> None:
+    async def mul(a: int, b: int) -> int:
         return a * b
 
-    await page.expose_function("compute", lambda a, b: asyncio.create_task(mul(a, b)))
+    await page.expose_function("compute", mul)
     assert await page.evaluate("compute(3, 5)") == 15
 
 
-async def test_expose_function_should_work_on_frames(page, server):
+async def test_expose_function_should_work_on_frames(
+    page: Page, server: Server
+) -> None:
     await page.expose_function("compute", lambda a, b: a * b)
     await page.goto(server.PREFIX + "/frames/nested-frames.html")
     frame = page.frames[1]
     assert await frame.evaluate("compute(3, 5)") == 15
 
 
-async def test_expose_function_should_work_on_frames_before_navigation(page, server):
+async def test_expose_function_should_work_on_frames_before_navigation(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/frames/nested-frames.html")
     await page.expose_function("compute", lambda a, b: a * b)
     frame = page.frames[1]
     assert await frame.evaluate("compute(3, 5)") == 15
 
 
-async def test_expose_function_should_work_after_cross_origin_navigation(page, server):
+async def test_expose_function_should_work_after_cross_origin_navigation(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.expose_function("compute", lambda a, b: a * b)
     await page.goto(server.CROSS_PROCESS_PREFIX + "/empty.html")
     assert await page.evaluate("compute(9, 4)") == 36
 
 
-async def test_expose_function_should_work_with_complex_objects(page, server):
+async def test_expose_function_should_work_with_complex_objects(
+    page: Page, server: Server
+) -> None:
     await page.expose_function("complexObject", lambda a, b: dict(x=a["x"] + b["x"]))
     result = await page.evaluate("complexObject({x: 5}, {x: 2})")
     assert result["x"] == 7
 
 
-async def test_expose_bindinghandle_should_work(page, server):
-    targets = []
-
-    def logme(t):
-        targets.append(t)
-        return 17
-
-    await page.expose_binding("logme", lambda source, t: logme(t), handle=True)
-    result = await page.evaluate("logme({ foo: 42 })")
-    assert (await targets[0].evaluate("x => x.foo")) == 42
-    assert result == 17
-
-
-async def test_page_error_should_fire(page, server, is_webkit):
-    [error, _] = await asyncio.gather(
-        page.wait_for_event("pageerror"),
-        page.goto(server.PREFIX + "/error.html"),
-    )
+async def test_page_error_should_fire(
+    page: Page, server: Server, browser_name: str
+) -> None:
+    url = server.PREFIX + "/error.html"
+    async with page.expect_event("pageerror") as error_info:
+        await page.goto(url)
+    error = await error_info.value
+    assert error.name == "Error"
     assert error.message == "Fancy error!"
-    stack = await page.evaluate("window.e.stack")
     # Note that WebKit reports the stack of the 'throw' statement instead of the Error constructor call.
-    if is_webkit:
-        stack = stack.replace("14:25", "15:19")
-    assert error.stack == stack
+    if browser_name == "chromium":
+        assert (
+            error.stack
+            == """Error: Fancy error!
+    at c (myscript.js:14:11)
+    at b (myscript.js:10:5)
+    at a (myscript.js:6:5)
+    at myscript.js:3:1"""
+        )
+    if browser_name == "firefox":
+        assert (
+            error.stack
+            == """Error: Fancy error!
+    at c (myscript.js:14:11)
+    at b (myscript.js:10:5)
+    at a (myscript.js:6:5)
+    at  (myscript.js:3:1)"""
+        )
+    if browser_name == "webkit":
+        assert (
+            error.stack
+            == f"""Error: Fancy error!
+    at c ({url}:14:36)
+    at b ({url}:10:6)
+    at a ({url}:6:6)
+    at global code ({url}:3:2)"""
+        )
 
 
-async def test_page_error_should_handle_odd_values(page, is_firefox):
+async def test_page_error_should_handle_odd_values(page: Page) -> None:
     cases = [["null", "null"], ["undefined", "undefined"], ["0", "0"], ['""', ""]]
     for [value, message] in cases:
-        [error, _] = await asyncio.gather(
-            page.wait_for_event("pageerror"),
-            page.evaluate(f"() => setTimeout(() => {{ throw {value}; }}, 0)"),
-        )
-        assert (
-            error.message == ("uncaught exception: " + message) if is_firefox else value
-        )
+        async with page.expect_event("pageerror") as error_info:
+            await page.evaluate(f"() => setTimeout(() => {{ throw {value}; }}, 0)")
+        error = await error_info.value
+        assert error.message == message
 
 
-@pytest.mark.skip_browser("firefox")
-async def test_page_error_should_handle_object(page, is_chromium):
-    # Firefox just does not report this error.
-    [error, _] = await asyncio.gather(
-        page.wait_for_event("pageerror"),
-        page.evaluate("() => setTimeout(() => { throw {}; }, 0)"),
-    )
+async def test_page_error_should_handle_object(page: Page, is_chromium: bool) -> None:
+    async with page.expect_event("pageerror") as error_info:
+        await page.evaluate("() => setTimeout(() => { throw {}; }, 0)")
+    error = await error_info.value
     assert error.message == "Object" if is_chromium else "[object Object]"
 
 
-@pytest.mark.skip_browser("firefox")
-async def test_page_error_should_handle_window(page, is_chromium):
-    # Firefox just does not report this error.
-    [error, _] = await asyncio.gather(
-        page.wait_for_event("pageerror"),
-        page.evaluate("() => setTimeout(() => { throw window; }, 0)"),
-    )
+async def test_page_error_should_handle_window(page: Page, is_chromium: bool) -> None:
+    async with page.expect_event("pageerror") as error_info:
+        await page.evaluate("() => setTimeout(() => { throw window; }, 0)")
+    error = await error_info.value
     assert error.message == "Window" if is_chromium else "[object Window]"
 
 
+async def test_page_error_should_pass_error_name_property(page: Page) -> None:
+    async with page.expect_event("pageerror") as error_info:
+        await page.evaluate(
+            """() => setTimeout(() => {
+            const error = new Error("my-message");
+            error.name = "my-name";
+            throw error;
+        }, 0)
+        """
+        )
+    error = await error_info.value
+    assert error.message == "my-message"
+    assert error.name == "my-name"
+
+
 expected_output = "<html><head></head><body><div>hello</div></body></html>"
 
 
-async def test_set_content_should_work(page, server):
+async def test_set_content_should_work(page: Page, server: Server) -> None:
     await page.set_content("<div>hello</div>")
     result = await page.content()
     assert result == expected_output
 
 
-async def test_set_content_should_work_with_domcontentloaded(page, server):
+async def test_set_content_should_work_with_domcontentloaded(
+    page: Page, server: Server
+) -> None:
     await page.set_content("<div>hello</div>", wait_until="domcontentloaded")
     result = await page.content()
     assert result == expected_output
 
 
-async def test_set_content_should_work_with_doctype(page, server):
+async def test_set_content_should_work_with_doctype(page: Page, server: Server) -> None:
     doctype = "<!DOCTYPE html>"
     await page.set_content(f"{doctype}<div>hello</div>")
     result = await page.content()
     assert result == f"{doctype}{expected_output}"
 
 
-async def test_set_content_should_work_with_HTML_4_doctype(page, server):
+async def test_set_content_should_work_with_HTML_4_doctype(
+    page: Page, server: Server
+) -> None:
     doctype = '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'
     await page.set_content(f"{doctype}<div>hello</div>")
     result = await page.content()
     assert result == f"{doctype}{expected_output}"
 
 
-async def test_set_content_should_respect_timeout(page, server):
+async def test_set_content_should_respect_timeout(page: Page, server: Server) -> None:
     img_path = "/img.png"
     # stall for image
     server.set_route(img_path, lambda request: None)
@@ -483,7 +661,9 @@ async def test_set_content_should_respect_timeout(page, server):
     assert exc_info.type is TimeoutError
 
 
-async def test_set_content_should_respect_default_navigation_timeout(page, server):
+async def test_set_content_should_respect_default_navigation_timeout(
+    page: Page, server: Server
+) -> None:
     page.set_default_navigation_timeout(1)
     img_path = "/img.png"
     # stall for image
@@ -495,14 +675,15 @@ async def test_set_content_should_respect_default_navigation_timeout(page, serve
     assert exc_info.type is TimeoutError
 
 
-async def test_set_content_should_await_resources_to_load(page, server):
-    img_path = "/img.png"
-    img_route = asyncio.Future()
-    await page.route(img_path, lambda route, request: img_route.set_result(route))
+async def test_set_content_should_await_resources_to_load(
+    page: Page, server: Server
+) -> None:
+    img_route: "asyncio.Future[Route]" = asyncio.Future()
+    await page.route("**/img.png", lambda route, request: img_route.set_result(route))
     loaded = []
 
-    async def load():
-        await page.set_content(f'<img src="{server.PREFIX + img_path}"></img>')
+    async def load() -> None:
+        await page.set_content(f'<img src="{server.PREFIX}/img.png"></img>')
         loaded.append(True)
 
     content_promise = asyncio.create_task(load())
@@ -513,49 +694,55 @@ async def load():
     await content_promise
 
 
-async def test_set_content_should_work_with_tricky_content(page):
-    await page.set_content("<div>hello world</div>" + "\x7F")
+async def test_set_content_should_work_with_tricky_content(page: Page) -> None:
+    await page.set_content("<div>hello world</div>" + "\x7f")
     assert await page.eval_on_selector("div", "div => div.textContent") == "hello world"
 
 
-async def test_set_content_should_work_with_accents(page):
+async def test_set_content_should_work_with_accents(page: Page) -> None:
     await page.set_content("<div>aberración</div>")
     assert await page.eval_on_selector("div", "div => div.textContent") == "aberración"
 
 
-async def test_set_content_should_work_with_emojis(page):
+async def test_set_content_should_work_with_emojis(page: Page) -> None:
     await page.set_content("<div>🐥</div>")
     assert await page.eval_on_selector("div", "div => div.textContent") == "🐥"
 
 
-async def test_set_content_should_work_with_newline(page):
+async def test_set_content_should_work_with_newline(page: Page) -> None:
     await page.set_content("<div>\n</div>")
     assert await page.eval_on_selector("div", "div => div.textContent") == "\n"
 
 
-async def test_add_script_tag_should_work_with_a_url(page, server):
+async def test_add_script_tag_should_work_with_a_url(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     script_handle = await page.add_script_tag(url="/injectedfile.js")
     assert script_handle.as_element()
     assert await page.evaluate("__injected") == 42
 
 
-async def test_add_script_tag_should_work_with_a_url_and_type_module(page, server):
+async def test_add_script_tag_should_work_with_a_url_and_type_module(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.add_script_tag(url="/es6/es6import.js", type="module")
     assert await page.evaluate("__es6injected") == 42
 
 
 async def test_add_script_tag_should_work_with_a_path_and_type_module(
-    page, server, assetdir
-):
+    page: Page, server: Server, assetdir: Path
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.add_script_tag(path=assetdir / "es6" / "es6pathimport.js", type="module")
     await page.wait_for_function("window.__es6injected")
     assert await page.evaluate("__es6injected") == 42
 
 
-async def test_add_script_tag_should_work_with_a_content_and_type_module(page, server):
+async def test_add_script_tag_should_work_with_a_content_and_type_module(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.add_script_tag(
         content="import num from '/es6/es6module.js';window.__es6injected = num;",
@@ -566,15 +753,17 @@ async def test_add_script_tag_should_work_with_a_content_and_type_module(page, s
 
 
 async def test_add_script_tag_should_throw_an_error_if_loading_from_url_fail(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     with pytest.raises(Error) as exc_info:
         await page.add_script_tag(url="/nonexistfile.js")
     assert exc_info.value
 
 
-async def test_add_script_tag_should_work_with_a_path(page, server, assetdir):
+async def test_add_script_tag_should_work_with_a_path(
+    page: Page, server: Server, assetdir: Path
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     script_handle = await page.add_script_tag(path=assetdir / "injectedfile.js")
     assert script_handle.as_element()
@@ -583,8 +772,8 @@ async def test_add_script_tag_should_work_with_a_path(page, server, assetdir):
 
 @pytest.mark.skip_browser("webkit")
 async def test_add_script_tag_should_include_source_url_when_path_is_provided(
-    page, server, assetdir
-):
+    page: Page, server: Server, assetdir: Path
+) -> None:
     # Lacking sourceURL support in WebKit
     await page.goto(server.EMPTY_PAGE)
     await page.add_script_tag(path=assetdir / "injectedfile.js")
@@ -592,7 +781,9 @@ async def test_add_script_tag_should_include_source_url_when_path_is_provided(
     assert os.path.join("assets", "injectedfile.js") in result
 
 
-async def test_add_script_tag_should_work_with_content(page, server):
+async def test_add_script_tag_should_work_with_content(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     script_handle = await page.add_script_tag(content="window.__injected = 35;")
     assert script_handle.as_element()
@@ -601,8 +792,8 @@ async def test_add_script_tag_should_work_with_content(page, server):
 
 @pytest.mark.skip_browser("firefox")
 async def test_add_script_tag_should_throw_when_added_with_content_to_the_csp_page(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     # Firefox fires onload for blocked script before it issues the CSP console error.
     await page.goto(server.PREFIX + "/csp.html")
     with pytest.raises(Error) as exc_info:
@@ -611,8 +802,8 @@ async def test_add_script_tag_should_throw_when_added_with_content_to_the_csp_pa
 
 
 async def test_add_script_tag_should_throw_when_added_with_URL_to_the_csp_page(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/csp.html")
     with pytest.raises(Error) as exc_info:
         await page.add_script_tag(url=server.CROSS_PROCESS_PREFIX + "/injectedfile.js")
@@ -620,8 +811,8 @@ async def test_add_script_tag_should_throw_when_added_with_URL_to_the_csp_page(
 
 
 async def test_add_script_tag_should_throw_a_nice_error_when_the_request_fails(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     url = server.PREFIX + "/this_does_not_exist.js"
     with pytest.raises(Error) as exc_info:
@@ -629,7 +820,7 @@ async def test_add_script_tag_should_throw_a_nice_error_when_the_request_fails(
     assert url in exc_info.value.message
 
 
-async def test_add_style_tag_should_work_with_a_url(page, server):
+async def test_add_style_tag_should_work_with_a_url(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     style_handle = await page.add_style_tag(url="/injectedstyle.css")
     assert style_handle.as_element()
@@ -642,15 +833,17 @@ async def test_add_style_tag_should_work_with_a_url(page, server):
 
 
 async def test_add_style_tag_should_throw_an_error_if_loading_from_url_fail(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     with pytest.raises(Error) as exc_info:
         await page.add_style_tag(url="/nonexistfile.js")
     assert exc_info.value
 
 
-async def test_add_style_tag_should_work_with_a_path(page, server, assetdir):
+async def test_add_style_tag_should_work_with_a_path(
+    page: Page, server: Server, assetdir: Path
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     style_handle = await page.add_style_tag(path=assetdir / "injectedstyle.css")
     assert style_handle.as_element()
@@ -663,8 +856,8 @@ async def test_add_style_tag_should_work_with_a_path(page, server, assetdir):
 
 
 async def test_add_style_tag_should_include_source_url_when_path_is_provided(
-    page, server, assetdir
-):
+    page: Page, server: Server, assetdir: Path
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.add_style_tag(path=assetdir / "injectedstyle.css")
     style_handle = await page.query_selector("style")
@@ -672,7 +865,9 @@ async def test_add_style_tag_should_include_source_url_when_path_is_provided(
     assert os.path.join("assets", "injectedstyle.css") in style_content
 
 
-async def test_add_style_tag_should_work_with_content(page, server):
+async def test_add_style_tag_should_work_with_content(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     style_handle = await page.add_style_tag(content="body { background-color: green; }")
     assert style_handle.as_element()
@@ -685,8 +880,8 @@ async def test_add_style_tag_should_work_with_content(page, server):
 
 
 async def test_add_style_tag_should_throw_when_added_with_content_to_the_CSP_page(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/csp.html")
     with pytest.raises(Error) as exc_info:
         await page.add_style_tag(content="body { background-color: green; }")
@@ -694,233 +889,54 @@ async def test_add_style_tag_should_throw_when_added_with_content_to_the_CSP_pag
 
 
 async def test_add_style_tag_should_throw_when_added_with_URL_to_the_CSP_page(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/csp.html")
     with pytest.raises(Error) as exc_info:
         await page.add_style_tag(url=server.CROSS_PROCESS_PREFIX + "/injectedstyle.css")
     assert exc_info.value
 
 
-async def test_url_should_work(page, server):
+async def test_url_should_work(page: Page, server: Server) -> None:
     assert page.url == "about:blank"
     await page.goto(server.EMPTY_PAGE)
     assert page.url == server.EMPTY_PAGE
 
 
-async def test_url_should_include_hashes(page, server):
+async def test_url_should_include_hashes(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE + "#hash")
     assert page.url == server.EMPTY_PAGE + "#hash"
     await page.evaluate("window.location.hash = 'dynamic'")
     assert page.url == server.EMPTY_PAGE + "#dynamic"
 
 
-async def test_title_should_return_the_page_title(page, server):
+async def test_title_should_return_the_page_title(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/title.html")
     assert await page.title() == "Woof-Woof"
 
 
-async def test_select_option_should_select_single_option(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.select_option("select", "blue")
-    assert await page.evaluate("result.onInput") == ["blue"]
-    assert await page.evaluate("result.onChange") == ["blue"]
-
-
-async def test_select_option_should_select_single_option_by_value(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.select_option("select", "blue")
-    assert await page.evaluate("result.onInput") == ["blue"]
-    assert await page.evaluate("result.onChange") == ["blue"]
-
-
-async def test_select_option_should_select_single_option_by_label(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.select_option("select", label="Indigo")
-    assert await page.evaluate("result.onInput") == ["indigo"]
-    assert await page.evaluate("result.onChange") == ["indigo"]
-
-
-async def test_select_option_should_select_single_option_by_handle(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.select_option(
-        "select", element=await page.query_selector("[id=whiteOption]")
-    )
-    assert await page.evaluate("result.onInput") == ["white"]
-    assert await page.evaluate("result.onChange") == ["white"]
-
-
-async def test_select_option_should_select_single_option_by_index(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.select_option("select", index=2)
-    assert await page.evaluate("result.onInput") == ["brown"]
-    assert await page.evaluate("result.onChange") == ["brown"]
-
-
-async def test_select_option_should_select_only_first_option(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.select_option("select", ["blue", "green", "red"])
-    assert await page.evaluate("result.onInput") == ["blue"]
-    assert await page.evaluate("result.onChange") == ["blue"]
-
-
-@pytest.mark.skip_browser("webkit")  # TODO: investigate
-async def test_select_option_should_not_throw_when_select_causes_navigation(
-    page, server
-):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.eval_on_selector(
-        "select",
-        "select => select.addEventListener('input', () => window.location = '/empty.html')",
-    )
-    await asyncio.gather(
-        page.wait_for_navigation(),
-        page.select_option("select", "blue"),
-    )
-    assert "empty.html" in page.url
-
-
-async def test_select_option_should_select_multiple_options(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.evaluate("makeMultiple()")
-    await page.select_option("select", ["blue", "green", "red"])
-    assert await page.evaluate("result.onInput") == ["blue", "green", "red"]
-    assert await page.evaluate("result.onChange") == ["blue", "green", "red"]
-
-
-async def test_select_option_should_select_multiple_options_with_attributes(
-    page, server
-):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.evaluate("makeMultiple()")
-    await page.select_option(
-        "select",
-        value="blue",
-        label="Green",
-        index=4,
-    )
-    assert await page.evaluate("result.onInput") == ["blue", "gray", "green"]
-    assert await page.evaluate("result.onChange") == ["blue", "gray", "green"]
-
-
-async def test_select_option_should_respect_event_bubbling(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.select_option("select", "blue")
-    assert await page.evaluate("result.onBubblingInput") == ["blue"]
-    assert await page.evaluate("result.onBubblingChange") == ["blue"]
-
-
-async def test_select_option_should_throw_when_element_is_not_a__select_(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    with pytest.raises(Error) as exc_info:
-        await page.select_option("body", "")
-    assert "Element is not a <select> element." in exc_info.value.message
-
-
-async def test_select_option_should_return_on_no_matched_values(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    result = await page.select_option("select", ["42", "abc"])
-    assert result == []
-
-
-async def test_select_option_should_return_an_array_of_matched_values(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.evaluate("makeMultiple()")
-    result = await page.select_option("select", ["blue", "black", "magenta"])
-    assert result == ["black", "blue", "magenta"]
-
-
-async def test_select_option_should_return_an_array_of_one_element_when_multiple_is_not_set(
-    page, server
-):
-    await page.goto(server.PREFIX + "/input/select.html")
-    result = await page.select_option("select", ["42", "blue", "black", "magenta"])
-    assert len(result) == 1
-
-
-async def test_select_option_should_return_on_no_values(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    result = await page.select_option("select", [])
-    assert result == []
-
-
-async def test_select_option_should_not_allow_null_items(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.evaluate("makeMultiple()")
-    with pytest.raises(Error) as exc_info:
-        await page.select_option("select", ["blue", None, "black", "magenta"])
-    assert "expected string, got object" in exc_info.value.message
-
-
-async def test_select_option_should_unselect_with_null(page, server):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.evaluate("makeMultiple()")
-    result = await page.select_option("select", ["blue", "black", "magenta"])
-    assert result == ["black", "blue", "magenta"]
-    await page.select_option("select", None)
-    assert await page.eval_on_selector(
-        "select",
-        "select => Array.from(select.options).every(option => !option.selected)",
-    )
-
-
-async def test_select_option_should_deselect_all_options_when_passed_no_values_for_a_multiple_select(
-    page, server
-):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.evaluate("makeMultiple()")
-    await page.select_option("select", ["blue", "black", "magenta"])
-    await page.select_option("select", [])
-    assert await page.eval_on_selector(
-        "select",
-        "select => Array.from(select.options).every(option => !option.selected)",
-    )
-
-
-async def test_select_option_should_deselect_all_options_when_passed_no_values_for_a_select_without_multiple(
-    page, server
-):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.select_option("select", ["blue", "black", "magenta"])
-    await page.select_option("select", [])
-    assert await page.eval_on_selector(
-        "select",
-        "select => Array.from(select.options).every(option => !option.selected)",
-    )
-
-
-async def test_select_option_should_work_when_re_defining_top_level_event_class(
-    page, server
-):
-    await page.goto(server.PREFIX + "/input/select.html")
-    await page.evaluate("window.Event = null")
-    await page.select_option("select", "blue")
-    assert await page.evaluate("result.onInput") == ["blue"]
-    assert await page.evaluate("result.onChange") == ["blue"]
-
-
-async def give_it_a_chance_to_fill(page):
+async def give_it_a_chance_to_fill(page: Page) -> None:
     for i in range(5):
         await page.evaluate(
             "() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f)))"
         )
 
 
-async def test_fill_should_fill_textarea(page, server):
+async def test_fill_should_fill_textarea(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.fill("textarea", "some value")
     assert await page.evaluate("result") == "some value"
 
 
-@pytest.mark.skip_browser("webkit")
-async def test_fill_should_fill_input(page, server):
-    # Disabled as in upstream, we should validate time in the Playwright lib
+async def test_fill_should_fill_input(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.fill("input", "some value")
     assert await page.evaluate("result") == "some value"
 
 
-async def test_fill_should_throw_on_unsupported_inputs(page, server):
+async def test_fill_should_throw_on_unsupported_inputs(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     for type in [
         "button",
@@ -928,7 +944,6 @@ async def test_fill_should_throw_on_unsupported_inputs(page, server):
         "file",
         "image",
         "radio",
-        "range",
         "reset",
         "submit",
     ]:
@@ -937,10 +952,12 @@ async def test_fill_should_throw_on_unsupported_inputs(page, server):
         )
         with pytest.raises(Error) as exc_info:
             await page.fill("input", "")
-        assert f'input of type "{type}" cannot be filled' in exc_info.value.message
+        assert f'Input of type "{type}" cannot be filled' in exc_info.value.message
 
 
-async def test_fill_should_fill_different_input_types(page, server):
+async def test_fill_should_fill_different_input_types(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     for type in ["password", "search", "tel", "text", "url"]:
         await page.eval_on_selector(
@@ -950,7 +967,9 @@ async def test_fill_should_fill_different_input_types(page, server):
         assert await page.evaluate("result") == "text " + type
 
 
-async def test_fill_should_fill_date_input_after_clicking(page, server):
+async def test_fill_should_fill_date_input_after_clicking(
+    page: Page, server: Server
+) -> None:
     await page.set_content("<input type=date>")
     await page.click("input")
     await page.fill("input", "2020-03-02")
@@ -958,7 +977,7 @@ async def test_fill_should_fill_date_input_after_clicking(page, server):
 
 
 @pytest.mark.skip_browser("webkit")
-async def test_fill_should_throw_on_incorrect_date(page, server):
+async def test_fill_should_throw_on_incorrect_date(page: Page, server: Server) -> None:
     # Disabled as in upstream, we should validate time in the Playwright lib
     await page.set_content("<input type=date>")
     with pytest.raises(Error) as exc_info:
@@ -966,14 +985,14 @@ async def test_fill_should_throw_on_incorrect_date(page, server):
     assert "Malformed value" in exc_info.value.message
 
 
-async def test_fill_should_fill_time_input(page, server):
+async def test_fill_should_fill_time_input(page: Page, server: Server) -> None:
     await page.set_content("<input type=time>")
     await page.fill("input", "13:15")
     assert await page.eval_on_selector("input", "input => input.value") == "13:15"
 
 
 @pytest.mark.skip_browser("webkit")
-async def test_fill_should_throw_on_incorrect_time(page, server):
+async def test_fill_should_throw_on_incorrect_time(page: Page, server: Server) -> None:
     # Disabled as in upstream, we should validate time in the Playwright lib
     await page.set_content("<input type=time>")
     with pytest.raises(Error) as exc_info:
@@ -981,7 +1000,9 @@ async def test_fill_should_throw_on_incorrect_time(page, server):
     assert "Malformed value" in exc_info.value.message
 
 
-async def test_fill_should_fill_datetime_local_input(page, server):
+async def test_fill_should_fill_datetime_local_input(
+    page: Page, server: Server
+) -> None:
     await page.set_content("<input type=datetime-local>")
     await page.fill("input", "2020-03-02T05:15")
     assert (
@@ -991,14 +1012,14 @@ async def test_fill_should_fill_datetime_local_input(page, server):
 
 
 @pytest.mark.only_browser("chromium")
-async def test_fill_should_throw_on_incorrect_datetime_local(page):
+async def test_fill_should_throw_on_incorrect_datetime_local(page: Page) -> None:
     await page.set_content("<input type=datetime-local>")
     with pytest.raises(Error) as exc_info:
         await page.fill("input", "abc")
     assert "Malformed value" in exc_info.value.message
 
 
-async def test_fill_should_fill_contenteditable(page, server):
+async def test_fill_should_fill_contenteditable(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.fill("div[contenteditable]", "some value")
     assert (
@@ -1008,8 +1029,8 @@ async def test_fill_should_fill_contenteditable(page, server):
 
 
 async def test_fill_should_fill_elements_with_existing_value_and_selection(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
 
     await page.eval_on_selector("input", "input => input.value = 'value one'")
@@ -1047,27 +1068,31 @@ async def test_fill_should_fill_elements_with_existing_value_and_selection(
 
 
 async def test_fill_should_throw_when_element_is_not_an_input_textarea_or_contenteditable(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     with pytest.raises(Error) as exc_info:
         await page.fill("body", "")
     assert "Element is not an <input>" in exc_info.value.message
 
 
-async def test_fill_should_throw_if_passed_a_non_string_value(page, server):
+async def test_fill_should_throw_if_passed_a_non_string_value(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     with pytest.raises(Error) as exc_info:
-        await page.fill("textarea", 123)
+        await page.fill("textarea", 123)  # type: ignore
     assert "expected string, got number" in exc_info.value.message
 
 
-async def test_fill_should_retry_on_disabled_element(page, server):
+async def test_fill_should_retry_on_disabled_element(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.eval_on_selector("input", "i => i.disabled = true")
     done = []
 
-    async def fill():
+    async def fill() -> None:
         await page.fill("input", "some value")
         done.append(True)
 
@@ -1081,12 +1106,14 @@ async def fill():
     assert await page.evaluate("result") == "some value"
 
 
-async def test_fill_should_retry_on_readonly_element(page, server):
+async def test_fill_should_retry_on_readonly_element(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.eval_on_selector("textarea", "i => i.readOnly = true")
     done = []
 
-    async def fill():
+    async def fill() -> None:
         await page.fill("textarea", "some value")
         done.append(True)
 
@@ -1100,12 +1127,14 @@ async def fill():
     assert await page.evaluate("result") == "some value"
 
 
-async def test_fill_should_retry_on_invisible_element(page, server):
+async def test_fill_should_retry_on_invisible_element(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.eval_on_selector("input", "i => i.style.display = 'none'")
     done = []
 
-    async def fill():
+    async def fill() -> None:
         await page.fill("input", "some value")
         done.append(True)
 
@@ -1119,19 +1148,21 @@ async def fill():
     assert await page.evaluate("result") == "some value"
 
 
-async def test_fill_should_be_able_to_fill_the_body(page):
+async def test_fill_should_be_able_to_fill_the_body(page: Page) -> None:
     await page.set_content('<body contentEditable="true"></body>')
     await page.fill("body", "some value")
     assert await page.evaluate("document.body.textContent") == "some value"
 
 
-async def test_fill_should_fill_fixed_position_input(page):
+async def test_fill_should_fill_fixed_position_input(page: Page) -> None:
     await page.set_content('<input style="position: fixed;" />')
     await page.fill("input", "some value")
     assert await page.evaluate("document.querySelector('input').value") == "some value"
 
 
-async def test_fill_should_be_able_to_fill_when_focus_is_in_the_wrong_frame(page):
+async def test_fill_should_be_able_to_fill_when_focus_is_in_the_wrong_frame(
+    page: Page,
+) -> None:
     await page.set_content(
         """
       <div contentEditable="true"></div>
@@ -1143,32 +1174,40 @@ async def test_fill_should_be_able_to_fill_when_focus_is_in_the_wrong_frame(page
     assert await page.eval_on_selector("div", "d => d.textContent") == "some value"
 
 
-async def test_fill_should_be_able_to_fill_the_input_type_number_(page):
+async def test_fill_should_be_able_to_fill_the_input_type_number_(page: Page) -> None:
     await page.set_content('<input id="input" type="number"></input>')
     await page.fill("input", "42")
     assert await page.evaluate("input.value") == "42"
 
 
-async def test_fill_should_be_able_to_fill_exponent_into_the_input_type_number_(page):
+async def test_fill_should_be_able_to_fill_exponent_into_the_input_type_number_(
+    page: Page,
+) -> None:
     await page.set_content('<input id="input" type="number"></input>')
     await page.fill("input", "-10e5")
     assert await page.evaluate("input.value") == "-10e5"
 
 
-async def test_fill_should_be_able_to_fill_input_type_number__with_empty_string(page):
+async def test_fill_should_be_able_to_fill_input_type_number__with_empty_string(
+    page: Page,
+) -> None:
     await page.set_content('<input id="input" type="number" value="123"></input>')
     await page.fill("input", "")
     assert await page.evaluate("input.value") == ""
 
 
-async def test_fill_should_not_be_able_to_fill_text_into_the_input_type_number_(page):
+async def test_fill_should_not_be_able_to_fill_text_into_the_input_type_number_(
+    page: Page,
+) -> None:
     await page.set_content('<input id="input" type="number"></input>')
     with pytest.raises(Error) as exc_info:
         await page.fill("input", "abc")
     assert "Cannot type text into input[type=number]" in exc_info.value.message
 
 
-async def test_fill_should_be_able_to_clear(page, server):
+async def test_fill_should_be_able_to_clear_using_fill(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.fill("input", "some value")
     assert await page.evaluate("result") == "some value"
@@ -1176,7 +1215,9 @@ async def test_fill_should_be_able_to_clear(page, server):
     assert await page.evaluate("result") == ""
 
 
-async def test_close_event_should_work_with_window_close(page, server):
+async def test_close_event_should_work_with_window_close(
+    page: Page, server: Server
+) -> None:
     async with page.expect_popup() as popup_info:
         await page.evaluate("window['newPage'] = window.open('about:blank')")
     popup = await popup_info.value
@@ -1185,17 +1226,21 @@ async def test_close_event_should_work_with_window_close(page, server):
         await page.evaluate("window['newPage'].close()")
 
 
-async def test_close_event_should_work_with_page_close(context, server):
+async def test_close_event_should_work_with_page_close(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     async with page.expect_event("close"):
         await page.close()
 
 
-async def test_page_context_should_return_the_correct_browser_instance(page, context):
+async def test_page_context_should_return_the_correct_browser_instance(
+    page: Page, context: BrowserContext
+) -> None:
     assert page.context == context
 
 
-async def test_frame_should_respect_name(page, server):
+async def test_frame_should_respect_name(page: Page, server: Server) -> None:
     await page.set_content("<iframe name=target></iframe>")
     assert page.frame(name="bogus") is None
     frame = page.frame(name="target")
@@ -1203,22 +1248,346 @@ async def test_frame_should_respect_name(page, server):
     assert frame == page.main_frame.child_frames[0]
 
 
-async def test_frame_should_respect_url(page, server):
+async def test_frame_should_respect_url(page: Page, server: Server) -> None:
     await page.set_content(f'<iframe src="{server.EMPTY_PAGE}"></iframe>')
     assert page.frame(url=re.compile(r"bogus")) is None
-    assert page.frame(url=re.compile(r"empty")).url == server.EMPTY_PAGE
+    assert must(page.frame(url=re.compile(r"empty"))).url == server.EMPTY_PAGE
 
 
-async def test_press_should_work(page, server):
+async def test_press_should_work(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/input/textarea.html")
     await page.press("textarea", "a")
     assert await page.evaluate("document.querySelector('textarea').value") == "a"
 
 
-async def test_frame_press_should_work(page, server):
+async def test_frame_press_should_work(page: Page, server: Server) -> None:
     await page.set_content(
         f'<iframe name=inner src="{server.PREFIX}/input/textarea.html"></iframe>'
     )
     frame = page.frame("inner")
+    assert frame
     await frame.press("textarea", "a")
     assert await frame.evaluate("document.querySelector('textarea').value") == "a"
+
+
+async def test_should_emulate_reduced_motion(page: Page, server: Server) -> None:
+    assert await page.evaluate(
+        "matchMedia('(prefers-reduced-motion: no-preference)').matches"
+    )
+    await page.emulate_media(reduced_motion="reduce")
+    assert await page.evaluate("matchMedia('(prefers-reduced-motion: reduce)').matches")
+    assert not await page.evaluate(
+        "matchMedia('(prefers-reduced-motion: no-preference)').matches"
+    )
+    await page.emulate_media(reduced_motion="no-preference")
+    assert not await page.evaluate(
+        "matchMedia('(prefers-reduced-motion: reduce)').matches"
+    )
+    assert await page.evaluate(
+        "matchMedia('(prefers-reduced-motion: no-preference)').matches"
+    )
+
+
+async def test_input_value(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/textarea.html")
+
+    await page.fill("input", "my-text-content")
+    assert await page.input_value("input") == "my-text-content"
+
+    await page.fill("input", "")
+    assert await page.input_value("input") == ""
+
+
+async def test_drag_and_drop_helper_method(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/drag-n-drop.html")
+    await page.drag_and_drop("#source", "#target")
+    assert (
+        await page.eval_on_selector(
+            "#target", "target => target.contains(document.querySelector('#source'))"
+        )
+        is True
+    )
+
+
+async def test_drag_and_drop_with_position(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content(
+        """
+      <div style="width:100px;height:100px;background:red;" id="red">
+      </div>
+      <div style="width:100px;height:100px;background:blue;" id="blue">
+      </div>
+    """
+    )
+    events_handle = await page.evaluate_handle(
+        """
+        () => {
+        const events = [];
+        document.getElementById('red').addEventListener('mousedown', event => {
+            events.push({
+            type: 'mousedown',
+            x: event.offsetX,
+            y: event.offsetY,
+            });
+        });
+        document.getElementById('blue').addEventListener('mouseup', event => {
+            events.push({
+            type: 'mouseup',
+            x: event.offsetX,
+            y: event.offsetY,
+            });
+        });
+        return events;
+        }
+    """
+    )
+    await page.drag_and_drop(
+        "#red",
+        "#blue",
+        source_position={"x": 34, "y": 7},
+        target_position={"x": 10, "y": 20},
+    )
+    assert await events_handle.json_value() == [
+        {"type": "mousedown", "x": 34, "y": 7},
+        {"type": "mouseup", "x": 10, "y": 20},
+    ]
+
+
+async def test_drag_and_drop_with_tweened_mouse_movement(page: Page) -> None:
+    await page.set_content(
+        """
+        <body style="margin: 0; padding: 0;">
+          <div style="width:100px;height:100px;background:red;" id="red"></div>
+          <div style="width:300px;height:100px;background:blue;" id="blue"></div>
+        </body>
+        """
+    )
+    events_handle = await page.evaluate_handle(
+        """
+        () => {
+            const events = [];
+            document.addEventListener('mousedown', event => {
+                events.push({
+                    type: 'mousedown',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            document.addEventListener('mouseup', event => {
+                events.push({
+                    type: 'mouseup',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            document.addEventListener('mousemove', event => {
+                events.push({
+                    type: 'mousemove',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            return events;
+        }
+        """
+    )
+    await page.drag_and_drop("#red", "#blue", steps=4)
+    assert await events_handle.json_value() == [
+        {"type": "mousemove", "x": 50, "y": 50},
+        {"type": "mousedown", "x": 50, "y": 50},
+        {"type": "mousemove", "x": 75, "y": 75},
+        {"type": "mousemove", "x": 100, "y": 100},
+        {"type": "mousemove", "x": 125, "y": 125},
+        {"type": "mousemove", "x": 150, "y": 150},
+        {"type": "mouseup", "x": 150, "y": 150},
+    ]
+
+
+async def test_locator_drag_to_with_tweened_mouse_movement(page: Page) -> None:
+    await page.set_content(
+        """
+        <body style="margin: 0; padding: 0;">
+          <div style="width:100px;height:100px;background:red;" id="red"></div>
+          <div style="width:300px;height:100px;background:blue;" id="blue"></div>
+        </body>
+        """
+    )
+    events_handle = await page.evaluate_handle(
+        """
+        () => {
+            const events = [];
+            document.addEventListener('mousedown', event => {
+                events.push({
+                    type: 'mousedown',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            document.addEventListener('mouseup', event => {
+                events.push({
+                    type: 'mouseup',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            document.addEventListener('mousemove', event => {
+                events.push({
+                    type: 'mousemove',
+                    x: event.pageX,
+                    y: event.pageY,
+                });
+            });
+            return events;
+        }
+        """
+    )
+    await page.locator("#red").drag_to(page.locator("#blue"), steps=4)
+    assert await events_handle.json_value() == [
+        {"type": "mousemove", "x": 50, "y": 50},
+        {"type": "mousedown", "x": 50, "y": 50},
+        {"type": "mousemove", "x": 75, "y": 75},
+        {"type": "mousemove", "x": 100, "y": 100},
+        {"type": "mousemove", "x": 125, "y": 125},
+        {"type": "mousemove", "x": 150, "y": 150},
+        {"type": "mouseup", "x": 150, "y": 150},
+    ]
+
+
+async def test_should_check_box_using_set_checked(page: Page) -> None:
+    await page.set_content("`<input id='checkbox' type='checkbox'></input>`")
+    await page.set_checked("input", True)
+    assert await page.evaluate("checkbox.checked") is True
+    await page.set_checked("input", False)
+    assert await page.evaluate("checkbox.checked") is False
+
+
+async def test_should_set_bodysize_and_headersize(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    async with page.expect_request("*/**") as request_info:
+        await page.evaluate(
+            "() => fetch('./get', { method: 'POST', body: '12345'}).then(r => r.text())"
+        )
+    request = await request_info.value
+    sizes = await request.sizes()
+    assert sizes["requestBodySize"] == 5
+    assert sizes["requestHeadersSize"] >= 300
+
+
+async def test_should_set_bodysize_to_0(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    async with page.expect_request("*/**") as request_info:
+        await page.evaluate("() => fetch('./get').then(r => r.text())")
+    request = await request_info.value
+    sizes = await request.sizes()
+    assert sizes["requestBodySize"] == 0
+    assert sizes["requestHeadersSize"] >= 200
+
+
+async def test_should_emulate_forced_colors(page: Page) -> None:
+    assert await page.evaluate("matchMedia('(forced-colors: none)').matches")
+    await page.emulate_media(forced_colors="none")
+    assert await page.evaluate("matchMedia('(forced-colors: none)').matches")
+    assert not await page.evaluate("matchMedia('(forced-colors: active)').matches")
+    await page.emulate_media(forced_colors="active")
+    assert await page.evaluate("matchMedia('(forced-colors: active)').matches")
+    assert not await page.evaluate("matchMedia('(forced-colors: none)').matches")
+
+
+async def test_should_emulate_contrast(page: Page) -> None:
+    assert await page.evaluate(
+        "matchMedia('(prefers-contrast: no-preference)').matches"
+    )
+    await page.emulate_media(contrast="no-preference")
+    assert await page.evaluate(
+        "matchMedia('(prefers-contrast: no-preference)').matches"
+    )
+    assert not await page.evaluate("matchMedia('(prefers-contrast: more)').matches")
+    await page.emulate_media(contrast="more")
+    assert not await page.evaluate(
+        "matchMedia('(prefers-contrast: no-preference)').matches"
+    )
+    assert await page.evaluate("matchMedia('(prefers-contrast: more)').matches")
+    await page.emulate_media(contrast="null")
+    assert await page.evaluate(
+        "matchMedia('(prefers-contrast: no-preference)').matches"
+    )
+
+
+async def test_should_not_throw_when_continuing_while_page_is_closing(
+    page: Page, server: Server
+) -> None:
+    done: Optional[asyncio.Future] = None
+
+    def handle_route(route: Route) -> None:
+        nonlocal done
+        done = asyncio.gather(route.continue_(), page.close())
+
+    await page.route("**/*", handle_route)
+    with pytest.raises(Error):
+        await page.goto(server.EMPTY_PAGE)
+    await must(done)
+
+
+async def test_should_not_throw_when_continuing_after_page_is_closed(
+    page: Page, server: Server
+) -> None:
+    done: "asyncio.Future[bool]" = asyncio.Future()
+
+    async def handle_route(route: Route) -> None:
+        await page.close()
+        await route.continue_()
+        done.set_result(True)
+
+    await page.route("**/*", handle_route)
+    with pytest.raises(Error):
+        await page.goto(server.EMPTY_PAGE)
+    await done
+
+
+async def test_expose_binding_should_serialize_cycles(page: Page) -> None:
+    binding_values = []
+
+    def binding(source: Dict, o: Dict) -> None:
+        binding_values.append(o)
+
+    await page.expose_binding("log", lambda source, o: binding(source, o))
+    await page.evaluate("const a = {}; a.b = a; window.log(a)")
+    assert binding_values[0]["b"] == binding_values[0]
+
+
+async def test_page_pause_should_reset_default_timeouts(
+    page: Page, headless: bool, server: Server
+) -> None:
+    if not headless:
+        pytest.skip()
+
+    await page.goto(server.EMPTY_PAGE)
+    await page.pause()
+    with pytest.raises(Error, match="Timeout 30000ms exceeded."):
+        await page.get_by_text("foo").click()
+
+
+async def test_page_pause_should_reset_custom_timeouts(
+    page: Page, headless: bool, server: Server
+) -> None:
+    if not headless:
+        pytest.skip()
+
+    page.set_default_timeout(123)
+    page.set_default_navigation_timeout(456)
+    await page.goto(server.EMPTY_PAGE)
+    await page.pause()
+    with pytest.raises(Error, match="Timeout 123ms exceeded."):
+        await page.get_by_text("foo").click()
+
+    server.set_route("/empty.html", lambda route: None)
+    with pytest.raises(Error, match="Timeout 456ms exceeded."):
+        await page.goto(server.EMPTY_PAGE)
+
+
+async def test_page_should_ignore_deprecated_is_hidden_and_visible_timeout(
+    page: Page,
+) -> None:
+    await page.set_content("<div>foo</div>")
+    assert await page.is_hidden("div", timeout=10) is False
+    assert await page.is_visible("div", timeout=10) is True
diff --git a/tests/async/test_page_add_locator_handler.py b/tests/async/test_page_add_locator_handler.py
new file mode 100644
index 000000000..ba798692e
--- /dev/null
+++ b/tests/async/test_page_add_locator_handler.py
@@ -0,0 +1,439 @@
+# 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 asyncio
+
+import pytest
+
+from playwright.async_api import Error, Locator, Page, expect
+from tests.server import Server
+from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
+
+
+async def test_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    before_count = 0
+    after_count = 0
+
+    original_locator = page.get_by_text("This interstitial covers the button")
+
+    async def handler(locator: Locator) -> None:
+        assert locator == original_locator
+        nonlocal before_count
+        nonlocal after_count
+        before_count += 1
+        await page.locator("#close").click()
+        after_count += 1
+
+    await page.add_locator_handler(original_locator, handler)
+
+    for args in [
+        ["mouseover", 1],
+        ["mouseover", 1, "capture"],
+        ["mouseover", 2],
+        ["mouseover", 2, "capture"],
+        ["pointerover", 1],
+        ["pointerover", 1, "capture"],
+        ["none", 1],
+        ["remove", 1],
+        ["hide", 1],
+    ]:
+        await page.locator("#aside").hover()
+        before_count = 0
+        after_count = 0
+        await page.evaluate(
+            "(args) => { window.clicked = 0; window.setupAnnoyingInterstitial(...args); }",
+            args,
+        )
+        assert before_count == 0
+        assert after_count == 0
+        await page.locator("#target").click()
+        assert before_count == args[1]
+        assert after_count == args[1]
+        assert await page.evaluate("window.clicked") == 1
+        await expect(page.locator("#interstitial")).not_to_be_visible()
+
+
+async def test_should_work_with_a_custom_check(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    async def handler() -> None:
+        if await page.get_by_text("This interstitial covers the button").is_visible():
+            await page.locator("#close").click()
+
+    await page.add_locator_handler(page.locator("body"), handler, no_wait_after=True)
+
+    for args in [
+        ["mouseover", 2],
+        ["none", 1],
+        ["remove", 1],
+        ["hide", 1],
+    ]:
+        await page.locator("#aside").hover()
+        await page.evaluate(
+            "(args) => { window.clicked = 0; window.setupAnnoyingInterstitial(...args); }",
+            args,
+        )
+        await page.locator("#target").click()
+        assert await page.evaluate("window.clicked") == 1
+        await expect(page.locator("#interstitial")).not_to_be_visible()
+
+
+async def test_should_work_with_keyword_only_handler(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    called = False
+
+    async def handler(*, timeout: object = None) -> None:
+        nonlocal called
+        assert timeout is None
+        called = True
+        await page.locator("#close").click()
+
+    await page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"), handler
+    )
+
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        '() => { window.clicked = 0; window.setupAnnoyingInterstitial("mouseover", 1); }'
+    )
+    await page.locator("#target").click()
+    assert called
+    assert await page.evaluate("window.clicked") == 1
+    await expect(page.locator("#interstitial")).not_to_be_visible()
+
+
+async def test_should_work_with_varargs_handler(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    called = False
+    original_locator = page.get_by_text("This interstitial covers the button")
+
+    async def handler(*locators: Locator) -> None:
+        nonlocal called
+        assert locators == (original_locator,)
+        called = True
+        await page.locator("#close").click()
+
+    await page.add_locator_handler(original_locator, handler)
+
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        '() => { window.clicked = 0; window.setupAnnoyingInterstitial("mouseover", 1); }'
+    )
+    await page.locator("#target").click()
+    assert called
+    assert await page.evaluate("window.clicked") == 1
+    await expect(page.locator("#interstitial")).not_to_be_visible()
+
+
+async def test_should_work_with_locator_hover(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    await page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"),
+        lambda: page.locator("#close").click(),
+    )
+
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        '() => { window.setupAnnoyingInterstitial("pointerover", 1, "capture"); }'
+    )
+    await page.locator("#target").hover()
+    await expect(page.locator("#interstitial")).not_to_be_visible()
+    assert (
+        await page.eval_on_selector(
+            "#target", "e => window.getComputedStyle(e).backgroundColor"
+        )
+        == "rgb(255, 255, 0)"
+    )
+
+
+async def test_should_not_work_with_force_true(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    await page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"),
+        lambda: page.locator("#close").click(),
+    )
+
+    await page.locator("#aside").hover()
+    await page.evaluate('() => { window.setupAnnoyingInterstitial("none", 1); }')
+    await page.locator("#target").click(force=True, timeout=2000)
+    assert await page.locator("#interstitial").is_visible()
+    assert await page.evaluate("window.clicked") is None
+
+
+async def test_should_throw_when_page_closes(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    await page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"), lambda: page.close()
+    )
+
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        '() => { window.clicked = 0; window.setupAnnoyingInterstitial("mouseover", 1); }'
+    )
+    with pytest.raises(Error) as exc:
+        await page.locator("#target").click()
+    assert TARGET_CLOSED_ERROR_MESSAGE in exc.value.message
+
+
+async def test_should_throw_when_handler_times_out(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    called = 0
+    stall_future: asyncio.Future[None] = asyncio.Future()
+
+    async def handler() -> None:
+        nonlocal called
+        called += 1
+        # Deliberately timeout.
+        await stall_future
+
+    await page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"), handler
+    )
+
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        '() => { window.clicked = 0; window.setupAnnoyingInterstitial("mouseover", 1); }'
+    )
+    with pytest.raises(Error) as exc:
+        await page.locator("#target").click(timeout=3000)
+    assert "Timeout 3000ms exceeded" in exc.value.message
+
+    with pytest.raises(Error) as exc:
+        await page.locator("#target").click(timeout=3000)
+    assert "Timeout 3000ms exceeded" in exc.value.message
+
+    # Should not enter the same handler while it is still running.
+    assert called == 1
+    stall_future.cancel()
+
+
+async def test_should_work_with_to_be_visible(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    called = 0
+
+    async def handler() -> None:
+        nonlocal called
+        called += 1
+        await page.locator("#close").click()
+
+    await page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"), handler
+    )
+
+    await page.evaluate(
+        '() => { window.clicked = 0; window.setupAnnoyingInterstitial("remove", 1); }'
+    )
+    await expect(page.locator("#target")).to_be_visible()
+    await expect(page.locator("#interstitial")).not_to_be_visible()
+    assert called == 1
+
+
+async def test_should_work_when_owner_frame_detaches(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate(
+        """
+    () => {
+        const iframe = document.createElement('iframe');
+        iframe.src = 'data:text/html,<body>hello from iframe</body>';
+        document.body.append(iframe);
+
+        const target = document.createElement('button');
+        target.textContent = 'Click me';
+        target.id = 'target';
+        target.addEventListener('click', () => window._clicked = true);
+        document.body.appendChild(target);
+
+        const closeButton = document.createElement('button');
+        closeButton.textContent = 'close';
+        closeButton.id = 'close';
+        closeButton.addEventListener('click', () => iframe.remove());
+        document.body.appendChild(closeButton);
+    }
+    """
+    )
+    await page.add_locator_handler(
+        page.frame_locator("iframe").locator("body"),
+        lambda: page.locator("#close").click(),
+    )
+    await page.locator("#target").click()
+    assert await page.query_selector("iframe") is None
+    assert await page.evaluate("window._clicked") is True
+
+
+async def test_should_work_with_times_option(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler() -> None:
+        nonlocal called
+        called += 1
+
+    await page.add_locator_handler(
+        page.locator("body"), _handler, no_wait_after=True, times=2
+    )
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('mouseover', 4);
+    }
+    """
+    )
+    with pytest.raises(Error) as exc_info:
+        await page.locator("#target").click(timeout=3000)
+    assert called == 2
+    assert await page.evaluate("window.clicked") == 0
+    await expect(page.locator("#interstitial")).to_be_visible()
+    assert "Timeout 3000ms exceeded" in exc_info.value.message
+    assert (
+        '<div>This interstitial covers the button</div> from <div class="visible" id="interstitial">…</div> subtree intercepts pointer events'
+        in exc_info.value.message
+    )
+
+
+async def test_should_wait_for_hidden_by_default(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    async def _handler(button: Locator) -> None:
+        nonlocal called
+        called += 1
+        await button.click()
+
+    await page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('timeout', 1);
+    }
+    """
+    )
+    await page.locator("#target").click()
+    assert await page.evaluate("window.clicked") == 1
+    await expect(page.locator("#interstitial")).not_to_be_visible()
+    assert called == 1
+
+
+async def test_should_wait_for_hidden_by_default_2(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler() -> None:
+        nonlocal called
+        called += 1
+
+    await page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    with pytest.raises(Error) as exc_info:
+        await page.locator("#target").click(timeout=3000)
+    assert await page.evaluate("window.clicked") == 0
+    assert await page.locator("#interstitial").is_visible()
+    assert called == 1
+    assert (
+        'locator handler has finished, waiting for get_by_role("button", name="close") to be hidden'
+        in exc_info.value.message
+    )
+
+
+async def test_should_work_with_noWaitAfter(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    async def _handler(button: Locator) -> None:
+        nonlocal called
+        called += 1
+        if called == 1:
+            await button.click()
+        else:
+            await page.locator("#interstitial").wait_for(state="hidden")
+
+    await page.add_locator_handler(
+        page.get_by_role("button", name="close"), _handler, no_wait_after=True
+    )
+    await page.locator("#aside").hover()
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('timeout', 1);
+    }
+    """
+    )
+    await page.locator("#target").click()
+    assert await page.evaluate("window.clicked") == 1
+    await expect(page.locator("#interstitial")).not_to_be_visible()
+    assert called == 2
+
+
+async def test_should_removeLocatorHandler(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    async def _handler(locator: Locator) -> None:
+        nonlocal called
+        called += 1
+        await locator.click()
+
+    await page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    await page.locator("#target").click()
+    assert called == 1
+    assert await page.evaluate("window.clicked") == 1
+    await expect(page.locator("#interstitial")).not_to_be_visible()
+    await page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    await page.remove_locator_handler(page.get_by_role("button", name="close"))
+    with pytest.raises(Error) as error:
+        await page.locator("#target").click(timeout=3000)
+    assert called == 1
+    assert await page.evaluate("window.clicked") == 0
+    await expect(page.locator("#interstitial")).to_be_visible()
+    assert "Timeout 3000ms exceeded" in error.value.message
diff --git a/tests/async/test_page_aria_snapshot.py b/tests/async/test_page_aria_snapshot.py
new file mode 100644
index 000000000..b4c4826ad
--- /dev/null
+++ b/tests/async/test_page_aria_snapshot.py
@@ -0,0 +1,277 @@
+# 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 re
+
+import pytest
+
+from playwright.async_api import Locator, Page, expect
+
+
+def _unshift(snapshot: str) -> str:
+    lines = snapshot.split("\n")
+    whitespace_prefix_length = 100
+    for line in lines:
+        if not line.strip():
+            continue
+        match = re.match(r"^(\s*)", line)
+        if match and len(match[1]) < whitespace_prefix_length:
+            whitespace_prefix_length = len(match[1])
+    return "\n".join(
+        [line[whitespace_prefix_length:] for line in lines if line.strip()]
+    )
+
+
+async def check_and_match_snapshot(locator: Locator, snapshot: str) -> None:
+    assert await locator.aria_snapshot() == _unshift(snapshot)
+    await expect(locator).to_match_aria_snapshot(snapshot, timeout=1000)
+
+
+async def test_should_snapshot(page: Page) -> None:
+    await page.set_content("<h1>title</h1>")
+    await check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - heading "title" [level=1]
+    """,
+    )
+
+
+async def test_should_snapshot_list(page: Page) -> None:
+    await page.set_content("<h1>title</h1><h1>title 2</h1>")
+    await check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - heading "title" [level=1]
+      - heading "title 2" [level=1]
+    """,
+    )
+
+
+async def test_should_snapshot_list_with_list(page: Page) -> None:
+    await page.set_content("<ul><li>one</li><li>two</li></ul>")
+    await check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list:
+        - listitem: one
+        - listitem: two
+    """,
+    )
+
+
+async def test_should_snapshot_list_with_accessible_name(page: Page) -> None:
+    await page.set_content('<ul aria-label="my list"><li>one</li><li>two</li></ul>')
+    await check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list "my list":
+        - listitem: one
+        - listitem: two
+    """,
+    )
+
+
+async def test_should_snapshot_complex(page: Page) -> None:
+    await page.set_content('<ul><li><a href="about:blank">link</a></li></ul>')
+    await check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list:
+        - listitem:
+          - link "link":
+            - /url: about:blank
+    """,
+    )
+
+
+async def test_should_snapshot_with_unexpected_children_equal(page: Page) -> None:
+    await page.set_content(
+        """
+      <ul>
+        <li>One</li>
+        <li>Two</li>
+        <li>Three</li>
+      </ul>
+    """
+    )
+    await expect(page.locator("body")).to_match_aria_snapshot(
+        """
+      - list:
+        - listitem: One
+        - listitem: Three
+    """,
+    )
+    with pytest.raises(AssertionError):
+        await expect(page.locator("body")).to_match_aria_snapshot(
+            """
+        - list:
+          - /children: equal
+          - listitem: One
+          - listitem: Three
+      """,
+            timeout=1000,
+        )
+
+
+async def test_should_snapshot_with_unexpected_children_deep_equal(page: Page) -> None:
+    await page.set_content(
+        """
+      <ul>
+        <li>
+          <ul>
+            <li>1.1</li>
+            <li>1.2</li>
+          </ul>
+        </li>
+      </ul>
+    """
+    )
+    await expect(page.locator("body")).to_match_aria_snapshot(
+        """
+      - list:
+        - listitem:
+          - list:
+            - listitem: 1.1
+    """,
+    )
+    await expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - list:
+          - /children: equal
+          - listitem:
+            - list:
+              - listitem: 1.1
+      """,
+    )
+    with pytest.raises(AssertionError):
+        await expect(page.locator("body")).to_match_aria_snapshot(
+            """
+          - list:
+            - /children: deep-equal
+            - listitem:
+              - list:
+                - listitem: 1.1
+        """,
+            timeout=1000,
+        )
+
+
+async def test_should_snapshot_with_restored_contain_mode_inside_deep_equal(
+    page: Page,
+) -> None:
+    await page.set_content(
+        """
+      <ul>
+        <li>
+          <ul>
+            <li>1.1</li>
+            <li>1.2</li>
+          </ul>
+        </li>
+      </ul>
+    """
+    )
+    with pytest.raises(AssertionError):
+        await expect(page.locator("body")).to_match_aria_snapshot(
+            """
+        - list:
+          - /children: deep-equal
+          - listitem:
+            - list:
+              - listitem: 1.1
+      """,
+            timeout=1000,
+        )
+    await expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - list:
+          - /children: deep-equal
+          - listitem:
+            - list:
+              - /children: contain
+              - listitem: 1.1
+      """,
+    )
+
+
+async def test_match_values_both_against_regex_and_string(page: Page) -> None:
+    await page.set_content('<a href="/auth?r=/">Log in</a>')
+    await expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - link "Log in":
+          - /url: /auth?r=/
+      """,
+    )
+
+
+async def test_should_snapshot_with_depth(page: Page) -> None:
+    await page.set_content("<ul><li><a href=about:blank>link</a></li></ul>")
+    snapshot = await page.locator("body").aria_snapshot(depth=1)
+    assert "listitem" in snapshot
+    assert "/url" not in snapshot
+
+
+async def test_page_aria_snapshot_should_work(page: Page) -> None:
+    await page.set_content("<h1>title</h1>")
+    snapshot = await page.aria_snapshot()
+    assert _unshift(snapshot) == _unshift(
+        """
+      - heading "title" [level=1]
+    """
+    )
+
+
+async def test_to_match_aria_snapshot_should_match_page(page: Page) -> None:
+    # Ported from upstream tests/page/to-match-aria-snapshot.spec.ts.
+    await page.set_content("<h1>title</h1>")
+    await expect(page).to_match_aria_snapshot(
+        """
+        - heading "title"
+        """
+    )
+
+
+async def test_to_match_aria_snapshot_should_match_page_complex(page: Page) -> None:
+    # Ported from upstream tests/page/to-match-aria-snapshot.spec.ts.
+    await page.set_content(
+        """
+        <h1>Microsoft</h1>
+        <div>Open source projects and samples from Microsoft</div>
+        <ul>
+          <li>
+            <a href="about:blank">Playwright</a>
+          </li>
+        </ul>
+        """
+    )
+    await expect(page).to_match_aria_snapshot(
+        """
+        - heading "Microsoft"
+        - text: Open source projects and samples from Microsoft
+        - list:
+          - listitem:
+            - link "Playwright"
+        """
+    )
+
+
+async def test_to_match_aria_snapshot_should_match_page_with_not(page: Page) -> None:
+    # Ported from upstream tests/page/to-match-aria-snapshot.spec.ts.
+    await page.set_content("<h1>title</h1>")
+    await expect(page).not_to_match_aria_snapshot(
+        """
+        - heading "wrong"
+        """
+    )
diff --git a/tests/async/test_page_base_url.py b/tests/async/test_page_base_url.py
new file mode 100644
index 000000000..3f0599e01
--- /dev/null
+++ b/tests/async/test_page_base_url.py
@@ -0,0 +1,118 @@
+# 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.
+
+from pathlib import Path
+from typing import Dict
+
+from playwright.async_api import Browser, BrowserType
+from tests.server import Server
+from tests.utils import must
+
+
+async def test_should_construct_a_new_url_when_a_base_url_in_browser_new_context_is_passed(
+    browser: Browser, server: Server
+) -> None:
+    context = await browser.new_context(base_url=server.PREFIX)
+    page = await context.new_page()
+    assert (must(await page.goto("/empty.html"))).url == server.EMPTY_PAGE
+    await context.close()
+
+
+async def test_should_construct_a_new_url_when_a_base_url_in_browser_new_page_is_passed(
+    browser: Browser, server: Server
+) -> None:
+    page = await browser.new_page(base_url=server.PREFIX)
+    assert (must(await page.goto("/empty.html"))).url == server.EMPTY_PAGE
+    await page.close()
+
+
+async def test_should_construct_a_new_url_when_a_base_url_in_browser_new_persistent_context_is_passed(
+    browser_type: BrowserType, tmp_path: Path, server: Server, launch_arguments: Dict
+) -> None:
+    context = await browser_type.launch_persistent_context(
+        tmp_path, **launch_arguments, base_url=server.PREFIX
+    )
+    page = await context.new_page()
+    assert (must(await page.goto("/empty.html"))).url == server.EMPTY_PAGE
+    await context.close()
+
+
+async def test_should_construct_correctly_when_a_baseurl_without_a_trailing_slash_is_passed(
+    browser: Browser, server: Server
+) -> None:
+    page = await browser.new_page(base_url=server.PREFIX + "/url-construction")
+    assert (must(await page.goto("mypage.html"))).url == server.PREFIX + "/mypage.html"
+    assert (
+        must(await page.goto("./mypage.html"))
+    ).url == server.PREFIX + "/mypage.html"
+    assert (must(await page.goto("/mypage.html"))).url == server.PREFIX + "/mypage.html"
+    await page.close()
+
+
+async def test_should_construct_correctly_when_a_baseurl_with_a_trailing_slash_is_passed(
+    browser: Browser, server: Server
+) -> None:
+    page = await browser.new_page(base_url=server.PREFIX + "/url-construction/")
+    assert (
+        must(await page.goto("mypage.html"))
+    ).url == server.PREFIX + "/url-construction/mypage.html"
+    assert (
+        must(await page.goto("./mypage.html"))
+    ).url == server.PREFIX + "/url-construction/mypage.html"
+    assert (must(await page.goto("/mypage.html"))).url == server.PREFIX + "/mypage.html"
+    assert (must(await page.goto("."))).url == server.PREFIX + "/url-construction/"
+    assert (must(await page.goto("/"))).url == server.PREFIX + "/"
+    await page.close()
+
+
+async def test_should_not_construct_a_new_url_when_valid_urls_are_passed(
+    browser: Browser, server: Server
+) -> None:
+    page = await browser.new_page(base_url="http://microsoft.com")
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.url == server.EMPTY_PAGE
+
+    await page.goto("data:text/html,Hello world")
+    assert page.url == "data:text/html,Hello world"
+
+    await page.goto("about:blank")
+    assert page.url == "about:blank"
+
+    await page.close()
+
+
+async def test_should_be_able_to_match_a_url_relative_to_its_given_url_with_urlmatcher(
+    browser: Browser, server: Server
+) -> None:
+    page = await browser.new_page(base_url=server.PREFIX + "/foobar/")
+
+    await page.goto("/kek/index.html")
+    await page.wait_for_url("/kek/index.html")
+    assert page.url == server.PREFIX + "/kek/index.html"
+
+    await page.route(
+        "./kek/index.html", lambda route: route.fulfill(body="base-url-matched-route")
+    )
+
+    async with page.expect_request("./kek/index.html") as request_info:
+        async with page.expect_response("./kek/index.html") as response_info:
+            await page.goto("./kek/index.html")
+    request = await request_info.value
+    response = await response_info.value
+    assert request.url == server.PREFIX + "/foobar/kek/index.html"
+    assert response.url == server.PREFIX + "/foobar/kek/index.html"
+    assert await response.body() == b"base-url-matched-route"
+
+    await page.close()
diff --git a/tests/async/test_page_clock.py b/tests/async/test_page_clock.py
new file mode 100644
index 000000000..cbe7740ea
--- /dev/null
+++ b/tests/async/test_page_clock.py
@@ -0,0 +1,487 @@
+# 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 asyncio
+import datetime
+from typing import Any, AsyncGenerator, List
+
+import pytest
+
+from playwright.async_api import Error, Page
+from tests.server import Server
+
+
+@pytest.fixture(autouse=True)
+async def calls(page: Page) -> List[Any]:
+    calls: List[Any] = []
+    await page.expose_function("stub", lambda *args: calls.append(list(args)))
+    return calls
+
+
+class TestRunFor:
+    @pytest.fixture(autouse=True)
+    async def before_each(self, page: Page) -> AsyncGenerator[None, None]:
+        await page.clock.install(time=0)
+        await page.clock.pause_at(1000)
+        yield
+
+    async def test_run_for_triggers_immediately_without_specified_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(window.stub)")
+        await page.clock.run_for(0)
+        assert len(calls) == 1
+
+    async def test_run_for_does_not_trigger_without_sufficient_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(window.stub, 100)")
+        await page.clock.run_for(10)
+        assert len(calls) == 0
+
+    async def test_run_for_triggers_after_sufficient_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(window.stub, 100)")
+        await page.clock.run_for(100)
+        assert len(calls) == 1
+
+    async def test_run_for_triggers_simultaneous_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            "setTimeout(window.stub, 100); setTimeout(window.stub, 100)"
+        )
+        await page.clock.run_for(100)
+        assert len(calls) == 2
+
+    async def test_run_for_triggers_multiple_simultaneous_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            "setTimeout(window.stub, 100); setTimeout(window.stub, 100); setTimeout(window.stub, 99); setTimeout(window.stub, 100)"
+        )
+        await page.clock.run_for(100)
+        assert len(calls) == 4
+
+    async def test_run_for_waits_after_setTimeout_was_called(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(window.stub, 150)")
+        await page.clock.run_for(50)
+        assert len(calls) == 0
+        await page.clock.run_for(100)
+        assert len(calls) == 1
+
+    async def test_run_for_triggers_event_when_some_throw(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            "setTimeout(() => { throw new Error(); }, 100); setTimeout(window.stub, 120)"
+        )
+        with pytest.raises(Error):
+            await page.clock.run_for(120)
+        assert len(calls) == 1
+
+    async def test_run_for_creates_updated_Date_while_ticking(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.clock.set_system_time(0)
+        await page.evaluate(
+            "setInterval(() => { window.stub(new Date().getTime()); }, 10)"
+        )
+        await page.clock.run_for(100)
+        assert calls == [
+            [10],
+            [20],
+            [30],
+            [40],
+            [50],
+            [60],
+            [70],
+            [80],
+            [90],
+            [100],
+        ]
+
+    async def test_run_for_passes_8_seconds(self, page: Page, calls: List[Any]) -> None:
+        await page.evaluate("setInterval(window.stub, 4000)")
+        await page.clock.run_for("08")
+        assert len(calls) == 2
+
+    async def test_run_for_passes_1_minute(self, page: Page, calls: List[Any]) -> None:
+        await page.evaluate("setInterval(window.stub, 6000)")
+        await page.clock.run_for("01:00")
+        assert len(calls) == 10
+
+    async def test_run_for_passes_2_hours_34_minutes_and_10_seconds(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setInterval(window.stub, 10000)")
+        await page.clock.run_for("02:34:10")
+        assert len(calls) == 925
+
+    async def test_run_for_throws_for_invalid_format(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setInterval(window.stub, 10000)")
+        with pytest.raises(Error):
+            await page.clock.run_for("12:02:34:10")
+        assert len(calls) == 0
+
+    async def test_run_for_returns_the_current_now_value(self, page: Page) -> None:
+        await page.clock.set_system_time(0)
+        value = 200
+        await page.clock.run_for(value)
+        assert await page.evaluate("Date.now()") == value
+
+
+class TestFastForward:
+    @pytest.fixture(autouse=True)
+    async def before_each(self, page: Page) -> AsyncGenerator[None, None]:
+        await page.clock.install(time=0)
+        await page.clock.pause_at(1)
+        yield
+
+    async def test_ignores_timers_which_wouldnt_be_run(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            "setTimeout(() => { window.stub('should not be logged'); }, 1000)"
+        )
+        await page.clock.fast_forward(500)
+        assert len(calls) == 0
+
+    async def test_pushes_back_execution_time_for_skipped_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(() => { window.stub(Date.now()); }, 1000)")
+        await page.clock.fast_forward(2000)
+        assert calls == [[1000 + 2000]]
+
+    async def test_supports_string_time_arguments(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            "setTimeout(() => { window.stub(Date.now()); }, 100000)"
+        )  # 100000 = 1:40
+        await page.clock.fast_forward("01:50")
+        assert calls == [[1000 + 110000]]
+
+
+class TestStubTimers:
+    @pytest.fixture(autouse=True)
+    async def before_each(self, page: Page) -> AsyncGenerator[None, None]:
+        await page.clock.install(time=0)
+        await page.clock.pause_at(1)
+        yield
+
+    async def test_sets_initial_timestamp(self, page: Page) -> None:
+        await page.clock.set_system_time(1.4)
+        assert await page.evaluate("Date.now()") == 1400
+
+    async def test_replaces_global_setTimeout(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setTimeout(window.stub, 1000)")
+        await page.clock.run_for(1000)
+        assert len(calls) == 1
+
+    async def test_global_fake_setTimeout_should_return_id(self, page: Page) -> None:
+        to = await page.evaluate("setTimeout(window.stub, 1000)")
+        assert isinstance(to, int)
+
+    async def test_replaces_global_clearTimeout(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            """
+            const to = setTimeout(window.stub, 1000);
+            clearTimeout(to);
+        """
+        )
+        await page.clock.run_for(1000)
+        assert len(calls) == 0
+
+    async def test_replaces_global_setInterval(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate("setInterval(window.stub, 500)")
+        await page.clock.run_for(1000)
+        assert len(calls) == 2
+
+    async def test_replaces_global_clearInterval(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.evaluate(
+            """
+            const to = setInterval(window.stub, 500);
+            clearInterval(to);
+        """
+        )
+        await page.clock.run_for(1000)
+        assert len(calls) == 0
+
+    async def test_replaces_global_performance_now(self, page: Page) -> None:
+        promise = asyncio.create_task(
+            page.evaluate(
+                """async () => {
+            const prev = performance.now();
+            await new Promise(f => setTimeout(f, 1000));
+            const next = performance.now();
+            return { prev, next };
+        }"""
+            )
+        )
+        await asyncio.sleep(0)  # Make sure the promise is scheduled.
+        await page.clock.run_for(1000)
+        assert await promise == {"prev": 1000, "next": 2000}
+
+    async def test_fakes_Date_constructor(self, page: Page) -> None:
+        now = await page.evaluate("new Date().getTime()")
+        assert now == 1000
+
+
+class TestStubTimersPerformance:
+    async def test_replaces_global_performance_time_origin(self, page: Page) -> None:
+        await page.clock.install(time=1)
+        await page.clock.pause_at(2)
+        promise = asyncio.create_task(
+            page.evaluate(
+                """async () => {
+            const prev = performance.now();
+            await new Promise(f => setTimeout(f, 1000));
+            const next = performance.now();
+            return { prev, next };
+        }"""
+            )
+        )
+        await asyncio.sleep(0)  # Make sure the promise is scheduled.
+        await page.clock.run_for(1000)
+        assert await page.evaluate("performance.timeOrigin") == 1000
+        assert await promise == {"prev": 1000, "next": 2000}
+
+
+class TestPopup:
+    async def test_should_tick_after_popup(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        now = datetime.datetime.fromisoformat("2015-09-25")
+        await page.clock.pause_at(now)
+        popup, _ = await asyncio.gather(
+            page.wait_for_event("popup"), page.evaluate("window.open('about:blank')")
+        )
+        popup_time = await popup.evaluate("Date.now()")
+        assert popup_time == now.timestamp() * 1000
+        await page.clock.run_for(1000)
+        popup_time_after = await popup.evaluate("Date.now()")
+        assert popup_time_after == now.timestamp() * 1000 + 1000
+
+    async def test_should_tick_before_popup(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        now = datetime.datetime.fromisoformat("2015-09-25")
+        await page.clock.pause_at(now)
+        await page.clock.run_for(1000)
+        popup, _ = await asyncio.gather(
+            page.wait_for_event("popup"), page.evaluate("window.open('about:blank')")
+        )
+        popup_time = await popup.evaluate("Date.now()")
+        assert popup_time == int(now.timestamp() * 1000 + 1000)
+        assert datetime.datetime.fromtimestamp(popup_time / 1_000).year == 2015
+
+    async def test_should_run_time_before_popup(
+        self, page: Page, server: Server
+    ) -> None:
+        server.set_route(
+            "/popup.html",
+            lambda res: (
+                res.setHeader("Content-Type", "text/html"),
+                res.write(b"<script>window.time = Date.now()</script>"),
+                res.finish(),
+            ),
+        )
+        await page.goto(server.EMPTY_PAGE)
+        # Wait for 2 second in real life to check that it is past in popup.
+        await page.wait_for_timeout(2000)
+        popup, _ = await asyncio.gather(
+            page.wait_for_event("popup"),
+            page.evaluate("window.open('{}')".format(server.PREFIX + "/popup.html")),
+        )
+        popup_time = await popup.evaluate("window.time")
+        assert popup_time >= 2000
+
+    async def test_should_not_run_time_before_popup_on_pause(
+        self, page: Page, server: Server
+    ) -> None:
+        server.set_route(
+            "/popup.html",
+            lambda res: (
+                res.setHeader("Content-Type", "text/html"),
+                res.write(b"<script>window.time = Date.now()</script>"),
+                res.finish(),
+            ),
+        )
+        await page.clock.install(time=0)
+        await page.clock.pause_at(1)
+        await page.goto(server.EMPTY_PAGE)
+        # Wait for 2 second in real life to check that it is past in popup.
+        await page.wait_for_timeout(2000)
+        popup, _ = await asyncio.gather(
+            page.wait_for_event("popup"),
+            page.evaluate("window.open('{}')".format(server.PREFIX + "/popup.html")),
+        )
+        popup_time = await popup.evaluate("window.time")
+        assert popup_time == 1000
+
+
+class TestSetFixedTime:
+    async def test_does_not_fake_methods(self, page: Page) -> None:
+        await page.clock.set_fixed_time(0)
+        # Should not stall.
+        await page.evaluate("new Promise(f => setTimeout(f, 1))")
+
+    async def test_allows_setting_time_multiple_times(self, page: Page) -> None:
+        await page.clock.set_fixed_time(0.1)
+        assert await page.evaluate("Date.now()") == 100
+        await page.clock.set_fixed_time(0.2)
+        assert await page.evaluate("Date.now()") == 200
+
+    async def test_fixed_time_is_not_affected_by_clock_manipulation(
+        self, page: Page
+    ) -> None:
+        await page.clock.set_fixed_time(0.1)
+        assert await page.evaluate("Date.now()") == 100
+        await page.clock.fast_forward(20)
+        assert await page.evaluate("Date.now()") == 100
+
+    async def test_allows_installing_fake_timers_after_setting_time(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.clock.set_fixed_time(0.1)
+        assert await page.evaluate("Date.now()") == 100
+        await page.clock.set_fixed_time(0.2)
+        await page.evaluate("setTimeout(() => window.stub(Date.now()))")
+        await page.clock.run_for(0)
+        assert calls == [[200]]
+
+
+class TestWhileRunning:
+    async def test_should_progress_time(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.wait_for_timeout(1000)
+        now = await page.evaluate("Date.now()")
+        assert 1000 <= now <= 2000
+
+    async def test_should_run_for(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.run_for(10000)
+        now = await page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    async def test_should_fast_forward(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.fast_forward(10000)
+        now = await page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    async def test_should_fast_forward_to(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.fast_forward(10000)
+        now = await page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    async def test_should_pause(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1)
+        await page.wait_for_timeout(1000)
+        now = await page.evaluate("Date.now()")
+        assert 0 <= now <= 1000
+
+    async def test_should_pause_and_fast_forward(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1)
+        await page.clock.fast_forward(1000)
+        now = await page.evaluate("Date.now()")
+        assert now == 2000
+
+    async def test_should_set_system_time_on_pause(self, page: Page) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1)
+        now = await page.evaluate("Date.now()")
+        assert now == 1000
+
+
+class TestWhileOnPause:
+    async def test_fast_forward_should_not_run_nested_immediate(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1000)
+        await page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                setTimeout(() => window.stub('inner'), 0);
+            }, 1000);
+        """
+        )
+        await page.clock.fast_forward(1000)
+        assert calls == [["outer"]]
+        await page.clock.fast_forward(1)
+        assert calls == [["outer"], ["inner"]]
+
+    async def test_run_for_should_not_run_nested_immediate(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1000)
+        await page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                setTimeout(() => window.stub('inner'), 0);
+            }, 1000);
+        """
+        )
+        await page.clock.run_for(1000)
+        assert calls == [["outer"]]
+        await page.clock.run_for(1)
+        assert calls == [["outer"], ["inner"]]
+
+    async def test_run_for_should_not_run_nested_immediate_from_microtask(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        await page.clock.install(time=0)
+        await page.goto("data:text/html,")
+        await page.clock.pause_at(1000)
+        await page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                void Promise.resolve().then(() => setTimeout(() => window.stub('inner'), 0));
+            }, 1000);
+        """
+        )
+        await page.clock.run_for(1000)
+        assert calls == [["outer"]]
+        await page.clock.run_for(1)
+        assert calls == [["outer"], ["inner"]]
diff --git a/tests/async/test_page_evaluate.py b/tests/async/test_page_evaluate.py
new file mode 100644
index 000000000..058263b18
--- /dev/null
+++ b/tests/async/test_page_evaluate.py
@@ -0,0 +1,355 @@
+# 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 math
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+from urllib.parse import ParseResult, urlparse
+
+from playwright.async_api import Error, Page
+
+
+async def test_evaluate_work(page: Page) -> None:
+    result = await page.evaluate("7 * 3")
+    assert result == 21
+
+
+async def test_evaluate_return_none_for_null(page: Page) -> None:
+    result = await page.evaluate("a => a", None)
+    assert result is None
+
+
+async def test_evaluate_transfer_nan(page: Page) -> None:
+    result = await page.evaluate("a => a", float("nan"))
+    assert math.isnan(result)
+
+
+async def test_evaluate_transfer_neg_zero(page: Page) -> None:
+    result = await page.evaluate("a => a", -0)
+    assert result == float("-0")
+
+
+async def test_evaluate_transfer_infinity(page: Page) -> None:
+    result = await page.evaluate("a => a", float("Infinity"))
+    assert result == float("Infinity")
+
+
+async def test_evaluate_transfer_neg_infinity(page: Page) -> None:
+    result = await page.evaluate("a => a", float("-Infinity"))
+    assert result == float("-Infinity")
+
+
+async def test_evaluate_roundtrip_unserializable_values(page: Page) -> None:
+    value = {
+        "infinity": float("Infinity"),
+        "nInfinity": float("-Infinity"),
+        "nZero": float("-0"),
+    }
+    result = await page.evaluate("a => a", value)
+    assert result == value
+
+
+async def test_evaluate_transfer_arrays(page: Page) -> None:
+    result = await page.evaluate("a => a", [1, 2, 3])
+    assert result == [1, 2, 3]
+
+
+async def test_evaluate_transfer_typed_arrays(page: Page) -> None:
+    async def test_typed_array(
+        typed_array: str, expected: list[float], value_suffix: Optional[str]
+    ) -> None:
+        value_suffix = "" if value_suffix is None else value_suffix
+        result = await page.evaluate(
+            f"() => new {typed_array}([1{value_suffix}, 2{value_suffix}, 3{value_suffix}])"
+        )
+        assert result == expected
+
+    await test_typed_array("Int8Array", [1, 2, 3], None)
+    await test_typed_array("Uint8Array", [1, 2, 3], None)
+    await test_typed_array("Uint8ClampedArray", [1, 2, 3], None)
+    await test_typed_array("Int16Array", [1, 2, 3], None)
+    await test_typed_array("Uint16Array", [1, 2, 3], None)
+    await test_typed_array("Int32Array", [1, 2, 3], None)
+    await test_typed_array("Uint32Array", [1, 2, 3], None)
+    await test_typed_array("Float32Array", [1.5, 2.5, 3.5], ".5")
+    await test_typed_array("Float64Array", [1.5, 2.5, 3.5], ".5")
+    await test_typed_array("BigInt64Array", [1, 2, 3], "n")
+    await test_typed_array("BigUint64Array", [1, 2, 3], "n")
+
+
+async def test_evaluate_transfer_bigint(page: Page) -> None:
+    assert await page.evaluate("() => 42n") == 42
+    assert await page.evaluate("a => a", 17) == 17
+
+
+async def test_evaluate_return_undefined_for_objects_with_symbols(page: Page) -> None:
+    assert await page.evaluate('[Symbol("foo4")]') == [None]
+    assert (
+        await page.evaluate(
+            """() => {
+                const a = { };
+                a[Symbol('foo4')] = 42;
+                return a;
+            }"""
+        )
+        == {}
+    )
+    assert (
+        await page.evaluate(
+            """() => {
+                return { foo: [{ a: Symbol('foo4') }] };
+            }"""
+        )
+        == {"foo": [{"a": None}]}
+    )
+
+
+async def test_evaluate_work_with_unicode_chars(page: Page) -> None:
+    result = await page.evaluate('a => a["中文字符"]', {"中文字符": 42})
+    assert result == 42
+
+
+async def test_evaluate_throw_when_evaluation_triggers_reload(page: Page) -> None:
+    error: Optional[Error] = None
+    try:
+        await page.evaluate(
+            "() => { location.reload(); return new Promise(() => {}); }"
+        )
+    except Error as e:
+        error = e
+    assert error
+    assert "navigation" in error.message
+
+
+async def test_evaluate_work_with_exposed_function(page: Page) -> None:
+    await page.expose_function("callController", lambda a, b: a * b)
+    result = await page.evaluate("callController(9, 3)")
+    assert result == 27
+
+
+async def test_evaluate_reject_promise_with_exception(page: Page) -> None:
+    error: Optional[Error] = None
+    try:
+        await page.evaluate("not_existing_object.property")
+    except Error as e:
+        error = e
+    assert error
+    assert "not_existing_object" in error.message
+
+
+async def test_evaluate_support_thrown_strings(page: Page) -> None:
+    error: Optional[Error] = None
+    try:
+        await page.evaluate('throw "qwerty"')
+    except Error as e:
+        error = e
+    assert error
+    assert "qwerty" in error.message
+
+
+async def test_evaluate_support_thrown_numbers(page: Page) -> None:
+    error: Optional[Error] = None
+    try:
+        await page.evaluate("throw 100500")
+    except Error as e:
+        error = e
+    assert error
+    assert "100500" in error.message
+
+
+async def test_evaluate_return_complex_objects(page: Page) -> None:
+    obj = {"foo": "bar!"}
+    result = await page.evaluate("a => a", obj)
+    assert result == obj
+
+
+async def test_evaluate_accept_none_as_one_of_multiple_parameters(page: Page) -> None:
+    result = await page.evaluate(
+        '({ a, b }) => Object.is(a, null) && Object.is(b, "foo")',
+        {"a": None, "b": "foo"},
+    )
+    assert result
+
+
+async def test_evaluate_properly_serialize_none_arguments(page: Page) -> None:
+    assert await page.evaluate("x => ({a: x})", None) == {"a": None}
+
+
+async def test_should_alias_window_document_and_node(page: Page) -> None:
+    object = await page.evaluate("[window, document, document.body]")
+    assert object == ["ref: <Window>", "ref: <Document>", "ref: <Node>"]
+
+
+async def test_evaluate_should_work_for_circular_object(page: Page) -> None:
+    a = await page.evaluate(
+        """() => {
+                const a = {x: 47};
+                const b = {a};
+                a.b = b;
+                return a;
+            }"""
+    )
+
+    assert a["b"]["a"]["b"]["a"]["x"] == 47
+    assert a["b"]["a"] == a
+
+
+async def test_evaluate_accept_string(page: Page) -> None:
+    assert await page.evaluate("1 + 2") == 3
+
+
+async def test_evaluate_accept_element_handle_as_an_argument(page: Page) -> None:
+    await page.set_content("<section>42</section>")
+    element = await page.query_selector("section")
+    text = await page.evaluate("e => e.textContent", element)
+    assert text == "42"
+
+
+async def test_evaluate_throw_if_underlying_element_was_disposed(page: Page) -> None:
+    await page.set_content("<section>39</section>")
+    element = await page.query_selector("section")
+    assert element
+    await element.dispose()
+    error: Optional[Error] = None
+    try:
+        await page.evaluate("e => e.textContent", element)
+    except Error as e:
+        error = e
+    assert error
+    assert "no object with guid" in error.message
+
+
+async def test_evaluate_evaluate_exception(page: Page) -> None:
+    error = await page.evaluate(
+        """() => {
+        function innerFunction() {
+        const e = new Error('error message');
+        e.name = 'foobar';
+        return e;
+        }
+        return innerFunction();
+    }"""
+    )
+    assert isinstance(error, Error)
+    assert error.message == "error message"
+    assert error.name == "foobar"
+    assert error.stack
+    assert "innerFunction" in error.stack
+
+
+async def test_should_pass_exception_argument(page: Page) -> None:
+    def _raise_and_get_exception(exception: Exception) -> Exception:
+        try:
+            raise exception
+        except Exception as e:
+            return e
+
+    error_for_roundtrip = Error("error message")
+    error_for_roundtrip._name = "foobar"
+    error_for_roundtrip._stack = "test stack"
+    error = await page.evaluate(
+        """e => {
+            return { message: e.message, name: e.name, stack: e.stack };
+        }""",
+        error_for_roundtrip,
+    )
+    assert error["message"] == "error message"
+    assert error["name"] == "foobar"
+    assert "test stack" in error["stack"]
+
+    error = await page.evaluate(
+        """e => {
+            return { message: e.message, name: e.name, stack: e.stack };
+        }""",
+        _raise_and_get_exception(Exception("error message")),
+    )
+    assert error["message"] == "error message"
+    assert error["name"] == "Exception"
+    assert "error message" in error["stack"]
+
+
+async def test_evaluate_evaluate_date(page: Page) -> None:
+    result = await page.evaluate(
+        '() => ({ date: new Date("2020-05-27T01:31:38.506Z") })'
+    )
+    assert result == {
+        "date": datetime.fromisoformat("2020-05-27T01:31:38.506").replace(
+            tzinfo=timezone.utc
+        )
+    }
+
+
+async def test_evaluate_roundtrip_date_without_tzinfo(page: Page) -> None:
+    date = datetime.fromisoformat("2020-05-27T01:31:38.506")
+    result = await page.evaluate("date => date", date)
+    assert result.timestamp() == date.timestamp()
+
+
+async def test_evaluate_roundtrip_date(page: Page) -> None:
+    date = datetime.fromisoformat("2020-05-27T01:31:38.506").replace(
+        tzinfo=timezone.utc
+    )
+    result = await page.evaluate("date => date", date)
+    assert result == date
+
+
+async def test_evaluate_roundtrip_date_with_tzinfo(page: Page) -> None:
+    date = datetime.fromisoformat("2020-05-27T01:31:38.506")
+    date = date.astimezone(timezone(timedelta(hours=4)))
+    result = await page.evaluate("date => date", date)
+    assert result == date
+
+
+async def test_evaluate_jsonvalue_date(page: Page) -> None:
+    date = datetime.fromisoformat("2020-05-27T01:31:38.506").replace(
+        tzinfo=timezone.utc
+    )
+    result = await page.evaluate(
+        '() => ({ date: new Date("2020-05-27T01:31:38.506Z") })'
+    )
+    assert result == {"date": date}
+
+
+async def test_should_evaluate_url(page: Page) -> None:
+    out = await page.evaluate(
+        "() => ({ someKey: new URL('https://user:pass@example.com/?foo=bar#hi') })"
+    )
+    assert out["someKey"] == ParseResult(
+        scheme="https",
+        netloc="user:pass@example.com",
+        path="/",
+        query="foo=bar",
+        params="",
+        fragment="hi",
+    )
+
+
+async def test_should_roundtrip_url(page: Page) -> None:
+    in_ = urlparse("https://user:pass@example.com/?foo=bar#hi")
+    out = await page.evaluate("url => url", in_)
+    assert in_ == out
+
+
+async def test_should_roundtrip_complex_url(page: Page) -> None:
+    in_ = urlparse(
+        "https://user:password@www.contoso.com:80/Home/Index.htm?q1=v1&q2=v2#FragmentName"
+    )
+    out = await page.evaluate("url => url", in_)
+    assert in_ == out
+
+
+async def test_evaluate_jsonvalue_url(page: Page) -> None:
+    url = urlparse("https://example.com/")
+    result = await page.evaluate('() => ({ someKey: new URL("https://example.com/") })')
+    assert result == {"someKey": url}
diff --git a/tests/async/test_page_event_console.py b/tests/async/test_page_event_console.py
new file mode 100644
index 000000000..2b6bc5ddf
--- /dev/null
+++ b/tests/async/test_page_event_console.py
@@ -0,0 +1,65 @@
+# 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.
+
+from playwright.async_api import Page
+from tests.server import Server
+
+
+async def test_console_messages_should_work(page: Page) -> None:
+    await page.evaluate(
+        """() => {
+            for (let i = 0; i < 301; i++)
+                console.log('message' + i);
+        }"""
+    )
+
+    messages = await page.console_messages()
+    objects = [{"text": m.text, "type": m.type, "page": m.page} for m in messages]
+
+    expected = []
+    for i in range(201, 301):
+        expected.append({"text": f"message{i}", "type": "log", "page": page})
+
+    assert len(objects) >= 100, "should be at least 100 messages"
+    message_count = len(messages) - len(expected)
+    assert objects[message_count:] == expected, "should return last messages"
+
+
+async def test_should_have_a_timestamp(page: Page) -> None:
+    async with page.expect_console_message() as message_info:
+        await page.evaluate("() => console.log('hello')")
+    message = await message_info.value
+    assert message.timestamp > 0
+
+
+async def test_clear_console_messages_should_drop_buffered_messages(page: Page) -> None:
+    await page.evaluate("() => console.log('first')")
+    assert any(m.text == "first" for m in await page.console_messages())
+    await page.clear_console_messages()
+    assert not any(m.text == "first" for m in await page.console_messages())
+    await page.evaluate("() => console.log('second')")
+    assert any(m.text == "second" for m in await page.console_messages())
+
+
+async def test_console_messages_filter_since_navigation_drops_pre_nav_messages(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate("() => console.log('before-nav')")
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate("() => console.log('after-nav')")
+    after = await page.console_messages(filter="since-navigation")
+    texts = [m.text for m in after]
+    assert "after-nav" in texts
+    assert "before-nav" not in texts
diff --git a/tests/async/test_page_event_pageerror.py b/tests/async/test_page_event_pageerror.py
new file mode 100644
index 000000000..a072f009e
--- /dev/null
+++ b/tests/async/test_page_event_pageerror.py
@@ -0,0 +1,60 @@
+# 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.
+
+from playwright.async_api import Page
+from tests.server import Server
+
+
+async def test_page_errors_should_work(page: Page) -> None:
+    await page.evaluate(
+        """async () => {
+            for (let i = 0; i < 301; i++)
+                window.setTimeout(() => { throw new Error('error' + i); }, 0);
+            await new Promise(f => window.setTimeout(f, 100));
+        }"""
+    )
+
+    errors = await page.page_errors()
+    messages = [e.message for e in errors]
+
+    expected = []
+    for i in range(201, 301):
+        expected.append(f"error{i}")
+
+    assert len(messages) >= 100, "should be at least 100 errors"
+    message_count = len(messages) - len(expected)
+    assert messages[message_count:] == expected, "should return last errors"
+
+
+async def test_clear_page_errors_should_drop_buffered_errors(page: Page) -> None:
+    await page.evaluate("() => setTimeout(() => { throw new Error('first'); }, 0)")
+    await page.evaluate("() => new Promise(r => setTimeout(r, 50))")
+    assert any(e.message == "first" for e in await page.page_errors())
+    await page.clear_page_errors()
+    assert not any(e.message == "first" for e in await page.page_errors())
+
+
+async def test_page_errors_filter_since_navigation_drops_pre_nav_errors(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate("() => setTimeout(() => { throw new Error('before-nav'); }, 0)")
+    await page.evaluate("() => new Promise(r => setTimeout(r, 50))")
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate("() => setTimeout(() => { throw new Error('after-nav'); }, 0)")
+    await page.evaluate("() => new Promise(r => setTimeout(r, 50))")
+    after = await page.page_errors(filter="since-navigation")
+    messages = [e.message for e in after]
+    assert "after-nav" in messages
+    assert "before-nav" not in messages
diff --git a/tests/async/test_page_event_request.py b/tests/async/test_page_event_request.py
new file mode 100644
index 000000000..73d6fd785
--- /dev/null
+++ b/tests/async/test_page_event_request.py
@@ -0,0 +1,62 @@
+# 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 asyncio
+
+from playwright._impl._network import Request, Route
+from playwright._impl._page import Page
+from tests.server import Server
+
+
+async def test_should_return_last_requests(page: Page, server: Server) -> None:
+    await page.goto(server.PREFIX + "/title.html")
+    for i in range(200):
+
+        def _handle_route(route: Route) -> None:
+            asyncio.ensure_future(
+                route.fulfill(
+                    status=200,
+                    body=f"url:{route.request.url}",
+                )
+            )
+
+        await page.route(f"**/fetch?{i}", _handle_route)
+
+    # #0 is the navigation request, so start with #1.
+    for i in range(1, 100):
+        await page.evaluate("url => fetch(url)", server.PREFIX + f"/fetch?{i}")
+    first_100_requests_with_goto = await page.requests()
+    first_100_requests = first_100_requests_with_goto[1:]
+
+    for i in range(100, 200):
+        await page.evaluate("url => fetch(url)", server.PREFIX + f"/fetch?{i}")
+    last_100_requests = await page.requests()
+
+    all_requests = first_100_requests + last_100_requests
+
+    async def gather_response(request: Request) -> dict:
+        response = await request.response()
+        assert response
+        return {"text": await response.text(), "url": request.url}
+
+    # All 199 requests are fully functional.
+    received = await asyncio.gather(
+        *[gather_response(request) for request in all_requests]
+    )
+
+    expected = []
+    for i in range(1, 200):
+        url = server.PREFIX + f"/fetch?{i}"
+        expected.append({"url": url, "text": f"url:{url}"})
+    assert received == expected
diff --git a/tests/async/test_page_network_request.py b/tests/async/test_page_network_request.py
new file mode 100644
index 000000000..bab4d5fd0
--- /dev/null
+++ b/tests/async/test_page_network_request.py
@@ -0,0 +1,84 @@
+# 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 asyncio
+
+import pytest
+
+from playwright.async_api import Error, Page, Request
+from tests.server import Server
+
+
+async def test_should_not_allow_to_access_frame_on_popup_main_request(
+    page: Page, server: Server
+) -> None:
+    await page.set_content(f'<a target=_blank href="{server.EMPTY_PAGE}">click me</a>')
+    request_promise = asyncio.ensure_future(page.context.wait_for_event("request"))
+    popup_promise = asyncio.ensure_future(page.context.wait_for_event("page"))
+    clicked = asyncio.ensure_future(page.get_by_text("click me").click())
+    request: Request = await request_promise
+
+    assert request.is_navigation_request()
+
+    with pytest.raises(Error) as exc_info:
+        request.frame
+    assert (
+        "Frame for this navigation request is not available" in exc_info.value.message
+    )
+
+    response = await request.response()
+    assert response
+    await response.finished()
+    await popup_promise
+    await clicked
+
+
+async def test_should_parse_the_data_if_content_type_is_application_x_www_form_urlencoded_charset_UTF_8(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    async with page.expect_event("request") as request_info:
+        await page.evaluate(
+            """() => fetch('./post', {
+            method: 'POST',
+            headers: {
+            'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            },
+            body: 'foo=bar&baz=123'
+        })"""
+        )
+    request = await request_info.value
+    assert request
+    assert request.post_data_json == {"foo": "bar", "baz": "123"}
+
+
+async def test_existing_response_should_return_response_after_it_is_received(
+    page: Page, server: Server
+) -> None:
+    async with page.expect_event("requestfinished") as request_finished_info:
+        await page.goto(server.EMPTY_PAGE)
+    request = await request_finished_info.value
+    assert request.existing_response is not None
+    assert request.existing_response.status == 200
+
+
+async def test_existing_response_should_return_none_before_response_arrives(
+    page: Page, server: Server
+) -> None:
+    captured = []
+    page.on("request", lambda req: captured.append(req.existing_response))
+    await page.goto(server.EMPTY_PAGE)
+    assert captured
+    # When the "request" event fires, the response has not been received yet.
+    assert captured[0] is None
diff --git a/tests/async/test_page_network_response.py b/tests/async/test_page_network_response.py
new file mode 100644
index 000000000..55bd5ff54
--- /dev/null
+++ b/tests/async/test_page_network_response.py
@@ -0,0 +1,79 @@
+# 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 asyncio
+
+import pytest
+
+from playwright.async_api import Error, Page
+from tests.server import Server, TestServerRequest
+
+
+async def test_should_reject_response_finished_if_page_closes(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    def handle_get(request: TestServerRequest) -> None:
+        # In Firefox, |fetch| will be hanging until it receives |Content-Type| header
+        # from server.
+        request.setHeader("Content-Type", "text/plain; charset=utf-8")
+        request.write(b"hello ")
+
+    server.set_route("/get", handle_get)
+    # send request and wait for server response
+    [page_response, _] = await asyncio.gather(
+        page.wait_for_event("response"),
+        page.evaluate("() => fetch('./get', { method: 'GET' })"),
+    )
+
+    finish_coroutine = page_response.finished()
+    await page.close()
+    with pytest.raises(Error) as exc_info:
+        await finish_coroutine
+    error = exc_info.value
+    assert "closed" in error.message
+
+
+async def test_should_reject_response_finished_if_context_closes(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    def handle_get(request: TestServerRequest) -> None:
+        # In Firefox, |fetch| will be hanging until it receives |Content-Type| header
+        # from server.
+        request.setHeader("Content-Type", "text/plain; charset=utf-8")
+        request.write(b"hello ")
+
+    server.set_route("/get", handle_get)
+    # send request and wait for server response
+    [page_response, _] = await asyncio.gather(
+        page.wait_for_event("response"),
+        page.evaluate("() => fetch('./get', { method: 'GET' })"),
+    )
+
+    finish_coroutine = page_response.finished()
+    await page.context.close()
+    with pytest.raises(Error) as exc_info:
+        await finish_coroutine
+    error = exc_info.value
+    assert "closed" in error.message
+
+
+async def test_should_return_http_version(page: Page, server: Server) -> None:
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    http_version = await response.http_version()
+    assert http_version in ("HTTP/1.0", "HTTP/1.1", "HTTP/2.0")
diff --git a/tests/async/test_page_request_fallback.py b/tests/async/test_page_request_fallback.py
new file mode 100644
index 000000000..1cea1204a
--- /dev/null
+++ b/tests/async/test_page_request_fallback.py
@@ -0,0 +1,368 @@
+# 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 asyncio
+from typing import Any, Callable, Coroutine, cast
+
+import pytest
+
+from playwright.async_api import Error, Page, Request, Route
+from tests.server import Server
+
+
+async def test_should_work(page: Page, server: Server) -> None:
+    await page.route("**/*", lambda route: asyncio.create_task(route.fallback()))
+    await page.goto(server.EMPTY_PAGE)
+
+
+async def test_should_fall_back(page: Page, server: Server) -> None:
+    intercepted = []
+
+    def _handler1(route: Route) -> None:
+        intercepted.append(1)
+        asyncio.create_task(route.fallback())
+
+    await page.route("**/empty.html", _handler1)
+
+    def _handler2(route: Route) -> None:
+        intercepted.append(2)
+        asyncio.create_task(route.fallback())
+
+    await page.route("**/empty.html", _handler2)
+
+    def _handler3(route: Route) -> None:
+        intercepted.append(3)
+        asyncio.create_task(route.fallback())
+
+    await page.route("**/empty.html", _handler3)
+
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+async def test_should_fall_back_async_delayed(page: Page, server: Server) -> None:
+    intercepted = []
+
+    def create_handler(i: int) -> Callable[[Route], Coroutine]:
+        async def handler(route: Route) -> None:
+            intercepted.append(i)
+            await asyncio.sleep(0.1)
+            await route.fallback()
+
+        return handler
+
+    await page.route("**/empty.html", create_handler(1))
+    await page.route("**/empty.html", create_handler(2))
+    await page.route("**/empty.html", create_handler(3))
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+async def test_should_chain_once(page: Page, server: Server) -> None:
+    await page.route(
+        "**/madeup.txt",
+        lambda route: asyncio.create_task(
+            route.fulfill(status=200, body="fulfilled one")
+        ),
+        times=1,
+    )
+    await page.route(
+        "**/madeup.txt", lambda route: asyncio.create_task(route.fallback()), times=1
+    )
+
+    resp = await page.goto(server.PREFIX + "/madeup.txt")
+    assert resp
+    body = await resp.body()
+    assert body == b"fulfilled one"
+
+
+async def test_should_not_chain_fulfill(page: Page, server: Server) -> None:
+    failed = [False]
+
+    def handler(route: Route) -> None:
+        failed[0] = True
+
+    await page.route("**/empty.html", handler)
+    await page.route(
+        "**/empty.html",
+        lambda route: asyncio.create_task(route.fulfill(status=200, body="fulfilled")),
+    )
+    await page.route(
+        "**/empty.html", lambda route: asyncio.create_task(route.fallback())
+    )
+
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    body = await response.body()
+    assert body == b"fulfilled"
+    assert not failed[0]
+
+
+async def test_should_not_chain_abort(
+    page: Page, server: Server, is_webkit: bool, is_firefox: bool
+) -> None:
+    failed = [False]
+
+    def handler(route: Route) -> None:
+        failed[0] = True
+
+    await page.route("**/empty.html", handler)
+    await page.route("**/empty.html", lambda route: asyncio.create_task(route.abort()))
+    await page.route(
+        "**/empty.html", lambda route: asyncio.create_task(route.fallback())
+    )
+
+    with pytest.raises(Error) as excinfo:
+        await page.goto(server.EMPTY_PAGE)
+    if is_webkit:
+        assert "Blocked by Web Inspector" in excinfo.value.message
+    elif is_firefox:
+        assert "NS_ERROR_FAILURE" in excinfo.value.message
+    else:
+        assert "net::ERR_FAILED" in excinfo.value.message
+    assert not failed[0]
+
+
+async def test_should_fall_back_after_exception(page: Page, server: Server) -> None:
+    await page.route("**/empty.html", lambda route: route.continue_())
+
+    async def handler(route: Route) -> None:
+        try:
+            await route.fulfill(response=cast(Any, {}))
+        except Exception:
+            await route.fallback()
+
+    await page.route("**/empty.html", handler)
+
+    await page.goto(server.EMPTY_PAGE)
+
+
+async def test_should_amend_http_headers(page: Page, server: Server) -> None:
+    values = []
+
+    async def handler(route: Route) -> None:
+        values.append(route.request.headers.get("foo"))
+        values.append(await route.request.header_value("FOO"))
+        await route.continue_()
+
+    await page.route("**/sleep.zzz", handler)
+
+    async def handler_with_header_mods(route: Route) -> None:
+        await route.fallback(headers={**route.request.headers, "FOO": "bar"})
+
+    await page.route("**/*", handler_with_header_mods)
+
+    await page.goto(server.EMPTY_PAGE)
+    with server.expect_request("/sleep.zzz") as server_request_info:
+        await page.evaluate("() => fetch('/sleep.zzz')")
+    values.append(server_request_info.value.getHeader("foo"))
+    assert values == ["bar", "bar", "bar"]
+
+
+async def test_should_delete_header_with_undefined_value(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    server.set_route(
+        "/something",
+        lambda r: (
+            r.setHeader("Acces-Control-Allow-Origin", "*"),
+            r.write(b"done"),
+            r.finish(),
+        ),
+    )
+
+    intercepted_request = []
+
+    async def capture_and_continue(route: Route, request: Request) -> None:
+        intercepted_request.append(request)
+        await route.continue_()
+
+    await page.route("**/*", capture_and_continue)
+
+    async def delete_foo_header(route: Route, request: Request) -> None:
+        headers = await request.all_headers()
+        del headers["foo"]
+        await route.fallback(headers=headers)
+
+    await page.route(server.PREFIX + "/something", delete_foo_header)
+
+    [server_req, text] = await asyncio.gather(
+        server.wait_for_request("/something"),
+        page.evaluate(
+            """
+            async url => {
+                const data = await fetch(url, {
+                    headers: {
+                    foo: 'a',
+                    bar: 'b',
+                    }
+                });
+                return data.text();
+                }
+            """,
+            server.PREFIX + "/something",
+        ),
+    )
+
+    assert text == "done"
+    assert not intercepted_request[0].headers.get("foo")
+    assert intercepted_request[0].headers.get("bar") == "b"
+    assert not server_req.getHeader("foo")
+    assert server_req.getHeader("bar") == "b"
+
+
+async def test_should_amend_method(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    method = []
+
+    def _handler(route: Route) -> None:
+        method.append(route.request.method)
+        asyncio.create_task(route.continue_())
+
+    await page.route("**/*", _handler)
+    await page.route(
+        "**/*", lambda route: asyncio.create_task(route.fallback(method="POST"))
+    )
+
+    [request, _] = await asyncio.gather(
+        server.wait_for_request("/sleep.zzz"),
+        page.evaluate("() => fetch('/sleep.zzz')"),
+    )
+
+    assert method == ["POST"]
+    assert request.method == b"POST"
+
+
+async def test_should_override_request_url(page: Page, server: Server) -> None:
+    url = []
+
+    def _handler1(route: Route) -> None:
+        url.append(route.request.url)
+        asyncio.create_task(route.continue_())
+
+    await page.route("**/global-var.html", _handler1)
+
+    def _handler2(route: Route) -> None:
+        asyncio.create_task(route.fallback(url=server.PREFIX + "/global-var.html"))
+
+    await page.route("**/foo", _handler2)
+
+    [server_request, response, _] = await asyncio.gather(
+        server.wait_for_request("/global-var.html"),
+        page.wait_for_event("response"),
+        page.goto(server.PREFIX + "/foo"),
+    )
+
+    assert url == [server.PREFIX + "/global-var.html"]
+    assert response.url == server.PREFIX + "/global-var.html"
+    assert response.request.url == server.PREFIX + "/global-var.html"
+    assert await page.evaluate("() => window['globalVar']") == 123
+    assert server_request.uri == b"/global-var.html"
+    assert server_request.method == b"GET"
+
+
+async def test_should_amend_post_data(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    post_data = []
+
+    def _handler(route: Route) -> None:
+        post_data.append(route.request.post_data)
+        asyncio.create_task(route.continue_())
+
+    await page.route("**/*", _handler)
+    await page.route(
+        "**/*", lambda route: asyncio.create_task(route.fallback(post_data="doggo"))
+    )
+    [server_request, _] = await asyncio.gather(
+        server.wait_for_request("/sleep.zzz"),
+        page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })"),
+    )
+    assert post_data == ["doggo"]
+    assert server_request.post_body == b"doggo"
+
+
+async def test_should_amend_binary_post_data(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    post_data_buffer = []
+
+    def _handler1(route: Route) -> None:
+        post_data_buffer.append(route.request.post_data)
+        asyncio.create_task(route.continue_())
+
+    await page.route("**/*", _handler1)
+
+    async def _handler2(route: Route) -> None:
+        await route.fallback(post_data=b"\x00\x01\x02\x03\x04")
+
+    await page.route("**/*", _handler2)
+
+    [server_request, result] = await asyncio.gather(
+        server.wait_for_request("/sleep.zzz"),
+        page.evaluate("fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })"),
+    )
+    # FIXME: should this be bytes?
+    assert post_data_buffer == ["\x00\x01\x02\x03\x04"]
+    assert server_request.method == b"POST"
+    assert server_request.post_body == b"\x00\x01\x02\x03\x04"
+
+
+async def test_should_chain_fallback_with_dynamic_url(
+    server: Server, page: Page
+) -> None:
+    intercepted = []
+
+    def _handler1(route: Route) -> None:
+        intercepted.append(1)
+        asyncio.create_task(route.fallback(url=server.EMPTY_PAGE))
+
+    await page.route("**/bar", _handler1)
+
+    def _handler2(route: Route, request: Request) -> None:
+        intercepted.append(2)
+        asyncio.create_task(route.fallback(url="http://localhost/bar"))
+
+    await page.route("**/foo", _handler2)
+
+    def _handler3(route: Route, request: Request) -> None:
+        intercepted.append(3)
+        asyncio.create_task(route.fallback(url="http://localhost/foo"))
+
+    await page.route("**/empty.html", _handler3)
+
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+async def test_should_amend_json_post_data(server: Server, page: Page) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    post_data = []
+
+    def _handle1(route: Route, request: Request) -> None:
+        post_data.append(route.request.post_data)
+        asyncio.create_task(route.continue_())
+
+    await page.route("**/*", _handle1)
+    await page.route(
+        "**/*",
+        lambda route: asyncio.create_task(route.fallback(post_data={"foo": "bar"})),
+    )
+
+    [server_request, _] = await asyncio.gather(
+        server.wait_for_request("/sleep.zzz"),
+        page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })"),
+    )
+    assert post_data == ['{"foo": "bar"}']
+    assert server_request.post_body == b'{"foo": "bar"}'
diff --git a/tests/async/test_page_request_gc.py b/tests/async/test_page_request_gc.py
new file mode 100644
index 000000000..7d0cce9ef
--- /dev/null
+++ b/tests/async/test_page_request_gc.py
@@ -0,0 +1,34 @@
+# 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.
+
+from playwright.async_api import Page
+from tests.server import Server
+
+
+async def test_should_work(page: Page, server: Server) -> None:
+    await page.evaluate(
+        """() => {
+        globalThis.objectToDestroy = { hello: 'world' };
+        globalThis.weakRef = new WeakRef(globalThis.objectToDestroy);
+    }"""
+    )
+    await page.request_gc()
+    assert await page.evaluate("() => globalThis.weakRef.deref()") == {"hello": "world"}
+
+    await page.request_gc()
+    assert await page.evaluate("() => globalThis.weakRef.deref()") == {"hello": "world"}
+
+    await page.evaluate("() => globalThis.objectToDestroy = null")
+    await page.request_gc()
+    assert await page.evaluate("() => globalThis.weakRef.deref()") is None
diff --git a/tests/async/test_page_request_intercept.py b/tests/async/test_page_request_intercept.py
new file mode 100644
index 000000000..d294031d5
--- /dev/null
+++ b/tests/async/test_page_request_intercept.py
@@ -0,0 +1,100 @@
+# 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 asyncio
+
+import pytest
+
+from playwright.async_api import Error, Page, Route, expect
+from tests.server import Server, TestServerRequest
+
+
+async def test_should_support_timeout_option_in_route_fetch(
+    server: Server, page: Page
+) -> None:
+    def _handler(request: TestServerRequest) -> None:
+        request.responseHeaders.addRawHeader("Content-Length", "4096")
+        request.responseHeaders.addRawHeader("Content-Type", "text/html")
+        request.write(b"")
+
+    server.set_route("/slow", _handler)
+
+    async def handle(route: Route) -> None:
+        with pytest.raises(Error) as error:
+            await route.fetch(timeout=1000)
+        assert "Route.fetch: Timeout 1000ms exceeded." in error.value.message
+
+    await page.route("**/*", lambda route: handle(route))
+    with pytest.raises(Error) as error:
+        await page.goto(server.PREFIX + "/slow", timeout=2000)
+    assert "Timeout 2000ms exceeded" in error.value.message
+
+
+async def test_should_not_follow_redirects_when_max_redirects_is_set_to_0_in_route_fetch(
+    server: Server, page: Page
+) -> None:
+    server.set_redirect("/foo", "/empty.html")
+
+    async def handle(route: Route) -> None:
+        response = await route.fetch(max_redirects=0)
+        assert response.headers["location"] == "/empty.html"
+        assert response.status == 302
+        await route.fulfill(body="hello")
+
+    await page.route("**/*", lambda route: handle(route))
+    await page.goto(server.PREFIX + "/foo")
+    assert "hello" in await page.content()
+
+
+async def test_should_intercept_with_url_override(server: Server, page: Page) -> None:
+    async def handle(route: Route) -> None:
+        response = await route.fetch(url=server.PREFIX + "/one-style.html")
+        await route.fulfill(response=response)
+
+    await page.route("**/*.html", lambda route: handle(route))
+    response = await page.goto(server.PREFIX + "/empty.html")
+    assert response
+    assert response.status == 200
+    assert "one-style.css" in (await response.body()).decode("utf-8")
+
+
+async def test_should_intercept_with_post_data_override(
+    server: Server, page: Page
+) -> None:
+    request_promise = asyncio.create_task(server.wait_for_request("/empty.html"))
+
+    async def handle(route: Route) -> None:
+        response = await route.fetch(post_data={"foo": "bar"})
+        await route.fulfill(response=response)
+
+    await page.route("**/*.html", lambda route: handle(route))
+    await page.goto(server.PREFIX + "/empty.html")
+    request = await request_promise
+    assert request.post_body
+    assert request.post_body.decode("utf-8") == '{"foo": "bar"}'
+
+
+async def test_should_fulfill_popup_main_request_using_alias(
+    page: Page, server: Server
+) -> None:
+    async def route_handler(route: Route) -> None:
+        response = await route.fetch()
+        await route.fulfill(response=response, body="hello")
+
+    await page.context.route("**/*", route_handler)
+    await page.set_content(f'<a target=_blank href="{server.EMPTY_PAGE}">click me</a>')
+    [popup, _] = await asyncio.gather(
+        page.wait_for_event("popup"), page.get_by_text("click me").click()
+    )
+    await expect(popup.locator("body")).to_have_text("hello")
diff --git a/tests/async/test_interception.py b/tests/async/test_page_route.py
similarity index 52%
rename from tests/async/test_interception.py
rename to tests/async/test_page_route.py
index 3ab6f921d..ecfac7f73 100644
--- a/tests/async/test_interception.py
+++ b/tests/async/test_page_route.py
@@ -14,22 +14,38 @@
 
 import asyncio
 import json
+import re
+from pathlib import Path
+from typing import Callable, List, Optional
 
 import pytest
 
-from playwright.async_api import Browser, Error, Page, Route
-
-
-async def test_page_route_should_intercept(page, server):
+from playwright._impl._glob import glob_to_regex_pattern
+from playwright._impl._helper import url_matches
+from playwright.async_api import (
+    Browser,
+    BrowserContext,
+    Error,
+    Page,
+    Playwright,
+    Request,
+    Route,
+    expect,
+)
+from tests.server import Server, TestServerRequest
+from tests.utils import must
+
+
+async def test_page_route_should_intercept(page: Page, server: Server) -> None:
     intercepted = []
 
-    async def handle_request(route, request):
+    async def handle_request(route: Route, request: Request) -> None:
         assert route.request == request
         assert "empty.html" in request.url
         assert request.headers["user-agent"]
         assert request.method == "GET"
         assert request.post_data is None
-        assert request.is_navigation_request
+        assert request.is_navigation_request()
         assert request.resource_type == "document"
         assert request.frame == page.main_frame
         assert request.frame.url == "about:blank"
@@ -39,57 +55,58 @@ async def handle_request(route, request):
     await page.route("**/empty.html", handle_request)
 
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.ok
     assert len(intercepted) == 1
 
 
-async def test_page_route_should_unroute(page: Page, server):
+async def test_page_route_should_unroute(page: Page, server: Server) -> None:
     intercepted = []
 
-    def handler1(route):
+    def _handle1(route: Route) -> None:
         intercepted.append(1)
         asyncio.create_task(route.continue_())
 
-    await page.route("**/empty.html", handler1)
-    await page.route(
-        "**/empty.html",
-        lambda route: (
-            intercepted.append(2),  # type: ignore
-            asyncio.create_task(route.continue_()),
-        ),
-    )
+    await page.route("**/*", _handle1)
+
+    def _handle2(route: Route, request: Request) -> None:
+        intercepted.append(2)
+        asyncio.create_task(route.continue_())
+
+    await page.route("**/empty.html", _handle2)
+
+    def _handle3(route: Route, request: Request) -> None:
+        intercepted.append(3)
+        asyncio.create_task(route.continue_())
 
     await page.route(
         "**/empty.html",
-        lambda route: (
-            intercepted.append(3),  # type: ignore
-            asyncio.create_task(route.continue_()),
-        ),
+        _handle3,
     )
 
-    await page.route(
-        "**/*",
-        lambda route: (
-            intercepted.append(4),  # type: ignore
-            asyncio.create_task(route.continue_()),
-        ),
-    )
+    def handler4(route: Route) -> None:
+        intercepted.append(4)
+        asyncio.create_task(route.continue_())
+
+    await page.route(re.compile("empty.html"), handler4)
 
     await page.goto(server.EMPTY_PAGE)
-    assert intercepted == [1]
+    assert intercepted == [4]
 
     intercepted = []
-    await page.unroute("**/empty.html", handler1)
+    await page.unroute(re.compile("empty.html"), handler4)
     await page.goto(server.EMPTY_PAGE)
-    assert intercepted == [2]
+    assert intercepted == [3]
 
     intercepted = []
     await page.unroute("**/empty.html")
     await page.goto(server.EMPTY_PAGE)
-    assert intercepted == [4]
+    assert intercepted == [1]
 
 
-async def test_page_route_should_work_when_POST_is_redirected_with_302(page, server):
+async def test_page_route_should_work_when_POST_is_redirected_with_302(
+    page: Page, server: Server
+) -> None:
     server.set_redirect("/rredirect", "/empty.html")
     await page.goto(server.EMPTY_PAGE)
     await page.route("**/*", lambda route: route.continue_())
@@ -100,16 +117,14 @@ async def test_page_route_should_work_when_POST_is_redirected_with_302(page, ser
       </form>
     """
     )
-    await asyncio.gather(
-        page.eval_on_selector("form", "form => form.submit()"),
-        page.wait_for_navigation(),
-    )
+    async with page.expect_navigation():
+        await page.eval_on_selector("form", "form => form.submit()")
 
 
 # @see https://github.com/GoogleChrome/puppeteer/issues/3973
 async def test_page_route_should_work_when_header_manipulation_headers_with_redirect(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     server.set_redirect("/rrredirect", "/empty.html")
     await page.route(
         "**/*",
@@ -120,8 +135,10 @@ async def test_page_route_should_work_when_header_manipulation_headers_with_redi
 
 
 # @see https://github.com/GoogleChrome/puppeteer/issues/4743
-async def test_page_route_should_be_able_to_remove_headers(page, server):
-    async def handle_request(route):
+async def test_page_route_should_be_able_to_remove_headers(
+    page: Page, server: Server
+) -> None:
+    async def handle_request(route: Route) -> None:
         headers = route.request.headers
         if "origin" in headers:
             del headers["origin"]
@@ -138,14 +155,18 @@ async def handle_request(route):
     assert serverRequest.getHeader("origin") is None
 
 
-async def test_page_route_should_contain_referer_header(page, server):
+async def test_page_route_should_contain_referer_header(
+    page: Page, server: Server
+) -> None:
     requests = []
+
+    def _handle(route: Route, request: Request) -> None:
+        requests.append(route.request)
+        asyncio.create_task(route.continue_())
+
     await page.route(
         "**/*",
-        lambda route: (
-            requests.append(route.request),
-            asyncio.create_task(route.continue_()),
-        ),
+        _handle,
     )
 
     await page.goto(server.PREFIX + "/one-style.html")
@@ -154,8 +175,8 @@ async def test_page_route_should_contain_referer_header(page, server):
 
 
 async def test_page_route_should_properly_return_navigation_response_when_URL_has_cookies(
-    context, page, server
-):
+    context: BrowserContext, page: Page, server: Server
+) -> None:
     # Setup cookie.
     await page.goto(server.EMPTY_PAGE)
     await context.add_cookies(
@@ -165,29 +186,36 @@ async def test_page_route_should_properly_return_navigation_response_when_URL_ha
     # Setup request interception.
     await page.route("**/*", lambda route: route.continue_())
     response = await page.reload()
+    assert response
     assert response.status == 200
 
 
-async def test_page_route_should_show_custom_HTTP_headers(page, server):
+async def test_page_route_should_show_custom_HTTP_headers(
+    page: Page, server: Server
+) -> None:
     await page.set_extra_http_headers({"foo": "bar"})
 
-    def assert_headers(request):
+    def assert_headers(request: Request) -> None:
         assert request.headers["foo"] == "bar"
 
+    def _handle(route: Route) -> None:
+        assert_headers(route.request)
+        asyncio.create_task(route.continue_())
+
     await page.route(
         "**/*",
-        lambda route: (
-            assert_headers(route.request),
-            asyncio.create_task(route.continue_()),
-        ),
+        _handle,
     )
 
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.ok
 
 
 # @see https://github.com/GoogleChrome/puppeteer/issues/4337
-async def test_page_route_should_work_with_redirect_inside_sync_XHR(page, server):
+async def test_page_route_should_work_with_redirect_inside_sync_XHR(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     server.set_redirect("/logo.png", "/pptr.png")
     await page.route("**/*", lambda route: route.continue_())
@@ -203,43 +231,48 @@ async def test_page_route_should_work_with_redirect_inside_sync_XHR(page, server
     assert status == 200
 
 
-async def test_page_route_should_work_with_custom_referer_headers(page, server):
+async def test_page_route_should_work_with_custom_referer_headers(
+    page: Page, server: Server
+) -> None:
     await page.set_extra_http_headers({"referer": server.EMPTY_PAGE})
 
-    def assert_headers(route):
+    def assert_headers(route: Route) -> None:
         assert route.request.headers["referer"] == server.EMPTY_PAGE
 
+    def _handle(route: Route, request: Request) -> None:
+        assert_headers(route)
+        asyncio.create_task(route.continue_())
+
     await page.route(
         "**/*",
-        lambda route: (
-            assert_headers(route),
-            asyncio.create_task(route.continue_()),
-        ),
+        _handle,
     )
 
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.ok
 
 
-async def test_page_route_should_be_abortable(page, server):
+async def test_page_route_should_be_abortable(page: Page, server: Server) -> None:
     await page.route(r"/\.css$/", lambda route: asyncio.create_task(route.abort()))
     failed = []
 
-    def handle_request(request):
-        if request.url.includes(".css"):
+    def handle_request(request: Request) -> None:
+        if ".css" in request.url:
             failed.append(True)
 
     page.on("requestfailed", handle_request)
 
     response = await page.goto(server.PREFIX + "/one-style.html")
+    assert response
     assert response.ok
     assert response.request.failure is None
     assert len(failed) == 0
 
 
 async def test_page_route_should_be_abortable_with_custom_error_codes(
-    page: Page, server, is_webkit, is_firefox
-):
+    page: Page, server: Server, is_webkit: bool, is_firefox: bool
+) -> None:
     await page.route(
         "**/*",
         lambda route: route.abort("internetdisconnected"),
@@ -251,14 +284,14 @@ async def test_page_route_should_be_abortable_with_custom_error_codes(
     assert len(failed_requests) == 1
     failed_request = failed_requests[0]
     if is_webkit:
-        assert failed_request.failure == "Request intercepted"
+        assert failed_request.failure == "Blocked by Web Inspector"
     elif is_firefox:
         assert failed_request.failure == "NS_ERROR_OFFLINE"
     else:
         assert failed_request.failure == "net::ERR_INTERNET_DISCONNECTED"
 
 
-async def test_page_route_should_send_referer(page, server):
+async def test_page_route_should_send_referer(page: Page, server: Server) -> None:
     await page.set_extra_http_headers({"referer": "http://google.com/"})
 
     await page.route("**/*", lambda route: route.continue_())
@@ -270,28 +303,32 @@ async def test_page_route_should_send_referer(page, server):
 
 
 async def test_page_route_should_fail_navigation_when_aborting_main_resource(
-    page, server, is_webkit, is_firefox
-):
+    page: Page, server: Server, is_webkit: bool, is_firefox: bool
+) -> None:
     await page.route("**/*", lambda route: route.abort())
     with pytest.raises(Error) as exc:
         await page.goto(server.EMPTY_PAGE)
     assert exc
     if is_webkit:
-        assert "Request intercepted" in exc.value.message
+        assert "Blocked by Web Inspector" in exc.value.message
     elif is_firefox:
         assert "NS_ERROR_FAILURE" in exc.value.message
     else:
         assert "net::ERR_FAILED" in exc.value.message
 
 
-async def test_page_route_should_not_work_with_redirects(page, server):
+async def test_page_route_should_not_work_with_redirects(
+    page: Page, server: Server
+) -> None:
     intercepted = []
+
+    def _handle(route: Route, request: Request) -> None:
+        asyncio.create_task(route.continue_())
+        intercepted.append(route.request)
+
     await page.route(
         "**/*",
-        lambda route: (
-            asyncio.create_task(route.continue_()),
-            intercepted.append(route.request),
-        ),
+        _handle,
     )
 
     server.set_redirect("/non-existing-page.html", "/non-existing-page-2.html")
@@ -300,19 +337,20 @@ async def test_page_route_should_not_work_with_redirects(page, server):
     server.set_redirect("/non-existing-page-4.html", "/empty.html")
 
     response = await page.goto(server.PREFIX + "/non-existing-page.html")
+    assert response
     assert response.status == 200
     assert "empty.html" in response.url
 
     assert len(intercepted) == 1
     assert intercepted[0].resource_type == "document"
-    assert intercepted[0].is_navigation_request
+    assert intercepted[0].is_navigation_request()
     assert "/non-existing-page.html" in intercepted[0].url
 
     chain = []
-    r = response.request
+    r: Optional[Request] = response.request
     while r:
         chain.append(r)
-        assert r.is_navigation_request
+        assert r.is_navigation_request()
         r = r.redirected_from
 
     assert len(chain) == 5
@@ -325,14 +363,18 @@ async def test_page_route_should_not_work_with_redirects(page, server):
         assert chain[idx].redirected_to == (chain[idx - 1] if idx > 0 else None)
 
 
-async def test_page_route_should_work_with_redirects_for_subresources(page, server):
-    intercepted = []
+async def test_page_route_should_work_with_redirects_for_subresources(
+    page: Page, server: Server
+) -> None:
+    intercepted: List[Request] = []
+
+    def _handle(route: Route) -> None:
+        asyncio.create_task(route.continue_())
+        intercepted.append(route.request)
+
     await page.route(
         "**/*",
-        lambda route: (
-            asyncio.create_task(route.continue_()),
-            intercepted.append(route.request),
-        ),
+        _handle,
     )
 
     server.set_redirect("/one-style.css", "/two-style.css")
@@ -344,40 +386,45 @@ async def test_page_route_should_work_with_redirects_for_subresources(page, serv
     )
 
     response = await page.goto(server.PREFIX + "/one-style.html")
+    assert response
     assert response.status == 200
     assert "one-style.html" in response.url
 
-    assert len(intercepted) == 2
+    # TODO: https://github.com/microsoft/playwright/issues/12789
+    assert len(intercepted) >= 2
     assert intercepted[0].resource_type == "document"
     assert "one-style.html" in intercepted[0].url
 
-    r = intercepted[1]
+    r: Optional[Request] = intercepted[1]
     for url in [
         "/one-style.css",
         "/two-style.css",
         "/three-style.css",
         "/four-style.css",
     ]:
+        assert r
         assert r.resource_type == "stylesheet"
         assert url in r.url
         r = r.redirected_to
     assert r is None
 
 
-async def test_page_route_should_work_with_equal_requests(page, server):
+async def test_page_route_should_work_with_equal_requests(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     hits = [True]
 
-    def handle_request(request, hits):
+    def handle_request(request: TestServerRequest, hits: List[bool]) -> None:
         request.write(str(len(hits) * 11).encode())
         request.finish()
         hits.append(True)
 
     server.set_route("/zzz", lambda r: handle_request(r, hits))
 
-    spinner = []
+    spinner: List[bool] = []
 
-    async def handle_route(route):
+    async def handle_route(route: Route) -> None:
         if len(spinner) == 1:
             await route.abort()
             spinner.pop(0)
@@ -399,15 +446,17 @@ async def handle_route(route):
 
 
 async def test_page_route_should_navigate_to_dataURL_and_not_fire_dataURL_requests(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     requests = []
+
+    def _handle(route: Route) -> None:
+        requests.append(route.request)
+        asyncio.create_task(route.continue_())
+
     await page.route(
         "**/*",
-        lambda route: (
-            requests.append(route.request),
-            asyncio.create_task(route.continue_()),
-        ),
+        _handle,
     )
 
     data_URL = "data:text/html,<div>yo</div>"
@@ -417,17 +466,16 @@ async def test_page_route_should_navigate_to_dataURL_and_not_fire_dataURL_reques
 
 
 async def test_page_route_should_be_able_to_fetch_dataURL_and_not_fire_dataURL_requests(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     requests = []
-    await page.route(
-        "**/*",
-        lambda route: (
-            requests.append(route.request),
-            asyncio.create_task(route.continue_()),
-        ),
-    )
+
+    def _handle(route: Route) -> None:
+        requests.append(route.request)
+        asyncio.create_task(route.continue_())
+
+    await page.route("**/*", _handle)
 
     data_URL = "data:text/html,<div>yo</div>"
     text = await page.evaluate("url => fetch(url).then(r => r.text())", data_URL)
@@ -436,72 +484,69 @@ async def test_page_route_should_be_able_to_fetch_dataURL_and_not_fire_dataURL_r
 
 
 async def test_page_route_should_navigate_to_URL_with_hash_and_and_fire_requests_without_hash(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     requests = []
+
+    def _handle(route: Route) -> None:
+        requests.append(route.request)
+        asyncio.create_task(route.continue_())
+
     await page.route(
         "**/*",
-        lambda route: (
-            requests.append(route.request),
-            asyncio.create_task(route.continue_()),
-        ),
+        _handle,
     )
 
     response = await page.goto(server.EMPTY_PAGE + "#hash")
+    assert response
     assert response.status == 200
     assert response.url == server.EMPTY_PAGE
     assert len(requests) == 1
     assert requests[0].url == server.EMPTY_PAGE
 
 
-async def test_page_route_should_work_with_encoded_server(page, server):
+async def test_page_route_should_work_with_encoded_server(
+    page: Page, server: Server
+) -> None:
     # The requestWillBeSent will report encoded URL, whereas interception will
     # report URL as-is. @see crbug.com/759388
     await page.route("**/*", lambda route: route.continue_())
     response = await page.goto(server.PREFIX + "/some nonexisting page")
+    assert response
     assert response.status == 404
 
 
-async def test_page_route_should_work_with_badly_encoded_server(page, server):
-    server.set_route("/malformed?rnd=%911", lambda req: req.finish())
-    await page.route("**/*", lambda route: route.continue_())
-    response = await page.goto(server.PREFIX + "/malformed?rnd=%911")
-    assert response.status == 200
-
-
-async def test_page_route_should_work_with_encoded_server___2(page, server):
+async def test_page_route_should_work_with_encoded_server___2(
+    page: Page, server: Server
+) -> None:
     # The requestWillBeSent will report URL as-is, whereas interception will
     # report encoded URL for stylesheet. @see crbug.com/759388
-    requests = []
-    await page.route(
-        "**/*",
-        lambda route: (
-            asyncio.create_task(route.continue_()),
-            requests.append(route.request),
-        ),
-    )
+    requests: List[Request] = []
+
+    def _handle(route: Route) -> None:
+        asyncio.create_task(route.continue_())
+        requests.append(route.request)
 
-    response = await page.goto(
+    await page.route("**/*", _handle)
+
+    await page.set_content(
         f"""data:text/html,<link rel="stylesheet" href="{server.PREFIX}/fonts?helvetica|arial"/>"""
     )
-    assert response is None
     assert len(requests) == 1
-    assert (await requests[0].response()).status == 404
+    assert (must(await requests[0].response())).status == 404
 
 
 async def test_page_route_should_not_throw_Invalid_Interception_Id_if_the_request_was_cancelled(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.set_content("<iframe></iframe>")
-    route_future = asyncio.Future()
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
     await page.route("**/*", lambda r, _: route_future.set_result(r))
 
-    await asyncio.gather(
-        page.wait_for_event("request"),  # Wait for request interception.
-        page.eval_on_selector(
+    async with page.expect_request("**/*"):
+        await page.eval_on_selector(
             "iframe", """(frame, url) => frame.src = url""", server.EMPTY_PAGE
-        ),
-    )
+        )
     # Delete frame to cause request to be canceled.
     await page.eval_on_selector("iframe", "frame => frame.remove()")
     route = await route_future
@@ -509,28 +554,31 @@ async def test_page_route_should_not_throw_Invalid_Interception_Id_if_the_reques
 
 
 async def test_page_route_should_intercept_main_resource_during_cross_process_navigation(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     intercepted = []
+
+    def _handle(route: Route) -> None:
+        intercepted.append(True)
+        asyncio.create_task(route.continue_())
+
     await page.route(
         server.CROSS_PROCESS_PREFIX + "/empty.html",
-        lambda route: (
-            intercepted.append(True),
-            asyncio.create_task(route.continue_()),
-        ),
+        _handle,
     )
 
     response = await page.goto(server.CROSS_PROCESS_PREFIX + "/empty.html")
+    assert response
     assert response.ok
     assert len(intercepted) == 1
 
 
 @pytest.mark.skip_browser("webkit")
-async def test_page_route_should_create_a_redirect(page, server):
+async def test_page_route_should_create_a_redirect(page: Page, server: Server) -> None:
     await page.goto(server.PREFIX + "/empty.html")
 
-    async def handle_route(route, request):
+    async def handle_route(route: Route, request: Request) -> None:
         if request.url != (server.PREFIX + "/redirect_this"):
             return await route.continue_()
         await route.fulfill(status=301, headers={"location": "/empty.html"})
@@ -550,15 +598,17 @@ async def handle_route(route, request):
     assert text == ""
 
 
-async def test_page_route_should_support_cors_with_GET(page, server):
+async def test_page_route_should_support_cors_with_GET(
+    page: Page, server: Server, browser_name: str
+) -> None:
     await page.goto(server.EMPTY_PAGE)
 
-    async def handle_route(route, request):
-        headers = (
-            {"access-control-allow-origin": "*"}
-            if request.url.endswith("allow")
-            else {}
-        )
+    async def handle_route(route: Route, request: Request) -> None:
+        headers = {
+            "access-control-allow-origin": (
+                "*" if request.url.endswith("allow") else "none"
+            )
+        }
         await route.fulfill(
             content_type="application/json",
             headers=headers,
@@ -588,10 +638,17 @@ async def handle_route(route, request):
             return response.json();
         }"""
         )
-    assert "failed" in exc.value.message
+    if browser_name == "chromium":
+        assert "Failed" in exc.value.message
+    elif browser_name == "webkit":
+        assert "TypeError" in exc.value.message
+    elif browser_name == "firefox":
+        assert "NetworkError" in exc.value.message
 
 
-async def test_page_route_should_support_cors_with_POST(page, server):
+async def test_page_route_should_support_cors_with_POST(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.route(
         "**/cars",
@@ -618,7 +675,9 @@ async def test_page_route_should_support_cors_with_POST(page, server):
     assert resp == ["electric", "gas"]
 
 
-async def test_page_route_should_support_cors_for_different_methods(page, server):
+async def test_page_route_should_support_cors_for_different_methods(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.route(
         "**/cars",
@@ -660,7 +719,7 @@ async def test_page_route_should_support_cors_for_different_methods(page, server
     assert resp == ["DELETE", "electric", "gas"]
 
 
-async def test_request_fulfill_should_work_a(page, server):
+async def test_request_fulfill_should_work_a(page: Page, server: Server) -> None:
     await page.route(
         "**/*",
         lambda route: route.fulfill(
@@ -672,26 +731,33 @@ async def test_request_fulfill_should_work_a(page, server):
     )
 
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.status == 201
     assert response.headers["foo"] == "bar"
     assert await page.evaluate("() => document.body.textContent") == "Yo, page!"
 
 
-async def test_request_fulfill_should_work_with_status_code_422(page, server):
+async def test_request_fulfill_should_work_with_status_code_422(
+    page: Page, server: Server
+) -> None:
     await page.route(
         "**/*",
         lambda route: route.fulfill(status=422, body="Yo, page!"),
     )
 
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.status == 422
     assert response.status_text == "Unprocessable Entity"
     assert await page.evaluate("() => document.body.textContent") == "Yo, page!"
 
 
 async def test_request_fulfill_should_allow_mocking_binary_responses(
-    page: Page, server, assert_to_be_golden, assetdir
-):
+    page: Page,
+    server: Server,
+    assert_to_be_golden: Callable[[bytes, str], None],
+    assetdir: Path,
+) -> None:
     await page.route(
         "**/*",
         lambda route: route.fulfill(
@@ -715,8 +781,8 @@ async def test_request_fulfill_should_allow_mocking_binary_responses(
 
 
 async def test_request_fulfill_should_allow_mocking_svg_with_charset(
-    page, server, assert_to_be_golden
-):
+    page: Page, server: Server, assert_to_be_golden: Callable[[bytes, str], None]
+) -> None:
     await page.route(
         "**/*",
         lambda route: route.fulfill(
@@ -735,12 +801,16 @@ async def test_request_fulfill_should_allow_mocking_svg_with_charset(
         server.PREFIX,
     )
     img = await page.query_selector("img")
+    assert img
     assert_to_be_golden(await img.screenshot(), "mock-svg.png")
 
 
 async def test_request_fulfill_should_work_with_file_path(
-    page: Page, server, assert_to_be_golden, assetdir
-):
+    page: Page,
+    server: Server,
+    assert_to_be_golden: Callable[[bytes, str], None],
+    assetdir: Path,
+) -> None:
     await page.route(
         "**/*",
         lambda route: route.fulfill(
@@ -762,16 +832,17 @@ async def test_request_fulfill_should_work_with_file_path(
 
 
 async def test_request_fulfill_should_stringify_intercepted_request_response_headers(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.route(
         "**/*",
         lambda route: route.fulfill(
-            status=200, headers={"foo": True}, body="Yo, page!"
+            status=200, headers={"foo": True}, body="Yo, page!"  # type: ignore
         ),
     )
 
     response = await page.goto(server.EMPTY_PAGE)
+    assert response
     assert response.status == 200
     headers = response.headers
     assert headers["foo"] == "True"
@@ -779,23 +850,21 @@ async def test_request_fulfill_should_stringify_intercepted_request_response_hea
 
 
 async def test_request_fulfill_should_not_modify_the_headers_sent_to_the_server(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/empty.html")
     interceptedRequests = []
 
     # this is just to enable request interception, which disables caching in chromium
     await page.route(server.PREFIX + "/unused", lambda route, req: None)
 
-    server.set_route(
-        "/something",
-        lambda response: (
-            interceptedRequests.append(response),
-            response.setHeader("Access-Control-Allow-Origin", "*"),
-            response.write(b"done"),
-            response.finish(),
-        ),
-    )
+    def _handler1(response: TestServerRequest) -> None:
+        interceptedRequests.append(response)
+        response.setHeader("Access-Control-Allow-Origin", "*")
+        response.write(b"done")
+        response.finish()
+
+    server.set_route("/something", _handler1)
 
     text = await page.evaluate(
         """async url => {
@@ -806,13 +875,15 @@ async def test_request_fulfill_should_not_modify_the_headers_sent_to_the_server(
     )
     assert text == "done"
 
-    playwrightRequest = asyncio.Future()
+    playwrightRequest: "asyncio.Future[Request]" = asyncio.Future()
+
+    def _handler2(route: Route, request: Request) -> None:
+        playwrightRequest.set_result(request)
+        asyncio.create_task(route.continue_(headers={**request.headers}))
+
     await page.route(
         server.CROSS_PROCESS_PREFIX + "/something",
-        lambda route, request: (
-            playwrightRequest.set_result(request),
-            asyncio.create_task(route.continue_(headers={**request.headers})),
-        ),
+        _handler2,
     )
 
     textAfterRoute = await page.evaluate(
@@ -830,22 +901,23 @@ async def test_request_fulfill_should_not_modify_the_headers_sent_to_the_server(
     )
 
 
-async def test_request_fulfill_should_include_the_origin_header(page, server):
+async def test_request_fulfill_should_include_the_origin_header(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/empty.html")
     interceptedRequest = []
-    await page.route(
-        server.CROSS_PROCESS_PREFIX + "/something",
-        lambda route, request: (
-            interceptedRequest.append(request),
-            asyncio.create_task(
-                route.fulfill(
-                    headers={"Access-Control-Allow-Origin": "*"},
-                    content_type="text/plain",
-                    body="done",
-                )
-            ),
-        ),
-    )
+
+    def _handle(route: Route, request: Request) -> None:
+        interceptedRequest.append(request)
+        asyncio.create_task(
+            route.fulfill(
+                headers={"Access-Control-Allow-Origin": "*"},
+                content_type="text/plain",
+                body="done",
+            )
+        )
+
+    await page.route(server.CROSS_PROCESS_PREFIX + "/something", _handle)
 
     text = await page.evaluate(
         """async url => {
@@ -859,26 +931,28 @@ async def test_request_fulfill_should_include_the_origin_header(page, server):
     assert interceptedRequest[0].headers["origin"] == server.PREFIX
 
 
-async def test_request_fulfill_should_work_with_request_interception(page, server):
+async def test_request_fulfill_should_work_with_request_interception(
+    page: Page, server: Server
+) -> None:
     requests = {}
 
-    def _handle_route(route: Route):
+    async def _handle_route(route: Route) -> None:
         requests[route.request.url.split("/").pop()] = route.request
-        asyncio.create_task(route.continue_())
+        await route.continue_()
 
     await page.route("**/*", _handle_route)
 
     server.set_redirect("/rrredirect", "/frames/one-frame.html")
     await page.goto(server.PREFIX + "/rrredirect")
-    assert requests["rrredirect"].is_navigation_request
-    assert requests["frame.html"].is_navigation_request
-    assert requests["script.js"].is_navigation_request is False
-    assert requests["style.css"].is_navigation_request is False
+    assert requests["rrredirect"].is_navigation_request()
+    assert requests["frame.html"].is_navigation_request()
+    assert requests["script.js"].is_navigation_request() is False
+    assert requests["style.css"].is_navigation_request() is False
 
 
 async def test_Interception_should_work_with_request_interception(
-    browser: Browser, https_server
-):
+    browser: Browser, https_server: Server
+) -> None:
     context = await browser.new_context(ignore_https_errors=True)
     page = await context.new_page()
 
@@ -890,8 +964,8 @@ async def test_Interception_should_work_with_request_interception(
 
 
 async def test_ignore_http_errors_service_worker_should_intercept_after_a_service_worker(
-    page, server
-):
+    page: Page, server: Server
+) -> None:
     await page.goto(server.PREFIX + "/serviceworkers/fetchdummy/sw.html")
     await page.evaluate("() => window.activationPromise")
 
@@ -899,7 +973,7 @@ async def test_ignore_http_errors_service_worker_should_intercept_after_a_servic
     sw_response = await page.evaluate('() => fetchDummy("foo")')
     assert sw_response == "responseFromServiceWorker:foo"
 
-    def _handle_route(route):
+    def _handle_route(route: Route) -> None:
         asyncio.ensure_future(
             route.fulfill(
                 status=200,
@@ -917,3 +991,273 @@ def _handle_route(route):
     # Page route is not applied to service worker initiated fetch.
     non_intercepted_response = await page.evaluate('() => fetchDummy("passthrough")')
     assert non_intercepted_response == "FAILURE: Not Found"
+
+
+async def test_page_route_should_support_times_parameter(
+    page: Page, server: Server
+) -> None:
+    intercepted = []
+
+    async def handle_request(route: Route) -> None:
+        await route.continue_()
+        intercepted.append(True)
+
+    await page.route("**/empty.html", handle_request, times=1)
+
+    await page.goto(server.EMPTY_PAGE)
+    await page.goto(server.EMPTY_PAGE)
+    await page.goto(server.EMPTY_PAGE)
+    assert len(intercepted) == 1
+
+
+async def test_should_work_if_handler_with_times_parameter_was_removed_from_another_handler(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    intercepted = []
+
+    async def handler(route: Route) -> None:
+        intercepted.append("first")
+        await route.continue_()
+
+    await page.route("**/*", handler, times=1)
+
+    async def handler2(route: Route) -> None:
+        intercepted.append("second")
+        await page.unroute("**/*", handler)
+        await route.fallback()
+
+    await page.route("**/*", handler2)
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == ["second"]
+    intercepted.clear()
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == ["second"]
+
+
+async def test_should_fulfill_with_global_fetch_result(
+    page: Page, playwright: Playwright, server: Server
+) -> None:
+    async def handle_request(route: Route) -> None:
+        request = await playwright.request.new_context()
+        response = await request.get(server.PREFIX + "/simple.json")
+        await route.fulfill(response=response)
+        await request.dispose()
+
+    await page.route("**/*", handle_request)
+
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 200
+    assert await response.json() == {"foo": "bar"}
+
+
+async def test_should_work_with_glob() -> None:
+    def glob_to_regex(pattern: str) -> re.Pattern:
+        return re.compile(glob_to_regex_pattern(pattern))
+
+    assert glob_to_regex("**/*.js").match("https://localhost:8080/foo.js")
+    assert not glob_to_regex("**/*.css").match("https://localhost:8080/foo.js")
+    assert not glob_to_regex("*.js").match(
+        "https://localhost:8080/foo.js"
+    )  # Doesn"t match path separator
+    assert glob_to_regex("https://**/*.js").match("https://localhost:8080/foo.js")
+    assert glob_to_regex("http://localhost:8080/simple/path.js").match(
+        "http://localhost:8080/simple/path.js"
+    )
+    assert glob_to_regex("**/{a,b}.js").match("https://localhost:8080/a.js")
+    assert glob_to_regex("**/{a,b}.js").match("https://localhost:8080/b.js")
+    assert not glob_to_regex("**/{a,b}.js").match("https://localhost:8080/c.js")
+
+    assert glob_to_regex("**/*.{png,jpg,jpeg}").match("https://localhost:8080/c.jpg")
+    assert glob_to_regex("**/*.{png,jpg,jpeg}").match("https://localhost:8080/c.jpeg")
+    assert glob_to_regex("**/*.{png,jpg,jpeg}").match("https://localhost:8080/c.png")
+    assert not glob_to_regex("**/*.{png,jpg,jpeg}").match(
+        "https://localhost:8080/c.css"
+    )
+    assert glob_to_regex("foo*").match("foo.js")
+    assert not glob_to_regex("foo*").match("foo/bar.js")
+    assert not glob_to_regex("http://localhost:3000/signin-oidc*").match(
+        "http://localhost:3000/signin-oidc/foo"
+    )
+    assert glob_to_regex("http://localhost:3000/signin-oidc*").match(
+        "http://localhost:3000/signin-oidcnice"
+    )
+
+    assert glob_to_regex("**/*.js").match("/foo.js")
+    assert not glob_to_regex("asd/**.js").match("/foo.js")
+    assert not glob_to_regex("**/*.js").match("bar_foo.js")
+
+    # range [] is NOT supported
+    assert glob_to_regex("**/api/v[0-9]").fullmatch("http://example.com/api/v[0-9]")
+    assert not glob_to_regex("**/api/v[0-9]").fullmatch(
+        "http://example.com/api/version"
+    )
+    assert not glob_to_regex("**/api/v[0-9]").fullmatch(
+        "http://example.com/api/v1"
+    )  # Should not match if [] is literal
+
+    # query params
+    assert glob_to_regex("**/api\\?param").match("http://example.com/api?param")
+    assert not glob_to_regex("**/api\\?param").match("http://example.com/api-param")
+
+    assert glob_to_regex("**/three-columns/settings.html\\?**id=settings-**").match(
+        "http://mydomain:8080/blah/blah/three-columns/settings.html?id=settings-e3c58efe-02e9-44b0-97ac-dd138100cf7c&blah"
+    )
+
+    assert glob_to_regex("\\?").pattern == r"^\?$"
+    assert glob_to_regex("\\").pattern == r"^\\$"
+    assert glob_to_regex("\\\\").pattern == r"^\\$"
+    assert glob_to_regex("\\[").pattern == r"^\[$"
+    assert glob_to_regex("[a-z]").pattern == r"^\[a-z\]$"
+    assert (
+        glob_to_regex("$^+.\\*()|\\?\\{\\}\\[\\]").pattern
+        == r"^\$\^\+\.\*\(\)\|\?\{\}\[\]$"
+    )
+
+    # --- url_matches tests ---
+    # Basic exact and wildcard matching
+    assert url_matches(None, "http://playwright.dev/", "http://playwright.dev")
+    assert url_matches(None, "http://playwright.dev/?a=b", "http://playwright.dev?a=b")
+    assert url_matches(None, "http://playwright.dev/", "h*://playwright.dev")
+    assert url_matches(
+        None, "http://api.playwright.dev/?x=y", "http://*.playwright.dev?x=y"
+    )
+    assert url_matches(None, "http://playwright.dev/foo/bar", "**/foo/**")
+
+    # Relative path matching with base URL
+    assert url_matches("http://playwright.dev", "http://playwright.dev/?x=y", "?x=y")
+    assert url_matches(
+        "http://playwright.dev/foo/", "http://playwright.dev/foo/bar?x=y", "./bar?x=y"
+    )
+
+    # Case insensitive matching
+    assert url_matches(
+        None, "https://playwright.dev/fooBAR", "HtTpS://pLaYwRiGhT.dEv/fooBAR"
+    )
+    assert url_matches(
+        "http://ignored",
+        "https://playwright.dev/fooBAR",
+        "HtTpS://pLaYwRiGhT.dEv/fooBAR",
+    )
+    # Path and search query are case-sensitive
+    assert not url_matches(
+        None, "https://playwright.dev/foobar", "https://playwright.dev/fooBAR"
+    )
+    assert not url_matches(
+        None, "https://playwright.dev/foobar?a=b", "https://playwright.dev/foobar?A=B"
+    )
+
+    assert url_matches(None, "https://localhost:3000/?a=b", "**/?a=b")
+    assert url_matches(None, "https://localhost:3000/?a=b", "**?a=b")
+    assert url_matches(None, "https://localhost:3000/?a=b", "**=b")
+
+    # Custom schema.
+    assert url_matches(None, "my.custom.protocol://foo", "my.custom.protocol://**")
+    assert not url_matches(None, "my.p://foo", "my.{p,y}://**")
+    assert url_matches(None, "my.p://foo/", "my.{p,y}://**")
+    assert url_matches(None, "file:///foo/", "f*e://**")
+
+    # This is not supported, we treat ? as a query separator.
+    assert not url_matches(
+        None,
+        "http://localhost:8080/Simple/path.js",
+        "http://localhost:8080/?imple/path.js",
+    )
+    assert not url_matches(None, "http://playwright.dev/", "http://playwright.?ev")
+    assert url_matches(None, "http://playwright./?ev", "http://playwright.?ev")
+    assert not url_matches(
+        None, "http://playwright.dev/foo", "http://playwright.dev/f??"
+    )
+    assert url_matches(None, "http://playwright.dev/f??", "http://playwright.dev/f??")
+    assert url_matches(
+        None, "http://playwright.dev/?x=y", r"http://playwright.dev\?x=y"
+    )
+    assert url_matches(
+        None, "http://playwright.dev/?x=y", r"http://playwright.dev/\?x=y"
+    )
+    assert url_matches(
+        "http://playwright.dev/foo", "http://playwright.dev/foo?bar", "?bar"
+    )
+    assert url_matches(
+        "http://playwright.dev/foo", "http://playwright.dev/foo?bar", r"\\?bar"
+    )
+    assert url_matches("http://first.host/", "http://second.host/foo", "**/foo")
+    assert url_matches("http://playwright.dev/", "http://localhost/", "*//localhost/")
+
+    # /**/ should match /.
+    assert url_matches(None, "https://foo/bar.js", "https://foo/**/bar.js")
+    assert url_matches(None, "https://foo/bar.js", "https://foo/**/**/bar.js")
+
+    custom_prefixes = ["about", "data", "chrome", "edge", "file"]
+    for prefix in custom_prefixes:
+        assert url_matches(
+            "http://playwright.dev/", f"{prefix}:blank", f"{prefix}:blank"
+        )
+        assert not url_matches(
+            "http://playwright.dev/", f"{prefix}:blank", "http://playwright.dev/"
+        )
+        assert url_matches(None, f"{prefix}:blank", f"{prefix}:blank")
+        assert url_matches(None, f"{prefix}:blank", f"{prefix}:*")
+        assert not url_matches(None, f"not{prefix}:blank", f"{prefix}:*")
+
+    # Added for Python implementation
+    assert url_matches(
+        None,
+        "custom://example.com/foo/bar?id=123",
+        "{custom,another}://example.com/foo/bar?id=123",
+    )
+    assert url_matches(
+        None, "custom://example.com/foo/bar?id=123", "**example.com/foo/bar?id=123"
+    )
+
+
+async def test_should_not_support_question_in_glob_pattern(
+    page: Page, playwright: Playwright, server: Server
+) -> None:
+    server.set_route("/index", lambda req: (req.write(b"index-no-hello"), req.finish()))
+    server.set_route(
+        "/index123hello", lambda req: (req.write(b"index123hello"), req.finish())
+    )
+    server.set_route(
+        "/index?hello", lambda req: (req.write(b"index?hello"), req.finish())
+    )
+    server.set_route(
+        "/index1hello", lambda req: (req.write(b"index1hello"), req.finish())
+    )
+
+    async def handle_any_char(route: Route) -> None:
+        await route.fulfill(body="intercepted any character")
+
+    await page.route("**/index?hello", handle_any_char)
+
+    async def handle_question_mark(route: Route) -> None:
+        await route.fulfill(body="intercepted question mark")
+
+    await page.route(r"**/index\?hello", handle_question_mark)
+
+    await page.goto(server.PREFIX + "/index?hello")
+    await expect(page.locator("body")).to_have_text("intercepted question mark")
+
+    await page.goto(server.PREFIX + "/index")
+    await expect(page.locator("body")).to_have_text("index-no-hello")
+
+    await page.goto(server.PREFIX + "/index1hello")
+    await expect(page.locator("body")).to_have_text("index1hello")
+
+    await page.goto(server.PREFIX + "/index123hello")
+    await expect(page.locator("body")).to_have_text("index123hello")
+
+
+async def test_page_route_returns_disposable(page: Page, server: Server) -> None:
+    intercepted: List[str] = []
+
+    async def handler(route: Route) -> None:
+        intercepted.append(route.request.url)
+        await route.continue_()
+
+    async with await page.route("**/*", handler):
+        await page.goto(server.EMPTY_PAGE)
+        assert any(server.EMPTY_PAGE in url for url in intercepted)
+    intercepted.clear()
+    await page.goto(server.EMPTY_PAGE)
+    assert intercepted == []
diff --git a/tests/async/test_page_select_option.py b/tests/async/test_page_select_option.py
new file mode 100644
index 000000000..c5edf543d
--- /dev/null
+++ b/tests/async/test_page_select_option.py
@@ -0,0 +1,273 @@
+# 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 pytest
+
+from playwright.async_api import Error, Page, TimeoutError
+from tests.server import Server
+
+
+async def test_select_option_should_select_single_option(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.select_option("select", "blue")
+    assert await page.evaluate("result.onInput") == ["blue"]
+    assert await page.evaluate("result.onChange") == ["blue"]
+
+
+async def test_select_option_should_select_single_option_by_value(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.select_option("select", "blue")
+    assert await page.evaluate("result.onInput") == ["blue"]
+    assert await page.evaluate("result.onChange") == ["blue"]
+
+
+async def test_select_option_should_select_single_option_by_label(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.select_option("select", label="Indigo")
+    assert await page.evaluate("result.onInput") == ["indigo"]
+    assert await page.evaluate("result.onChange") == ["indigo"]
+
+
+async def test_select_option_should_select_single_option_by_empty_label(
+    page: Page, server: Server
+) -> None:
+    await page.set_content(
+        """
+        <select>
+            <option value="indigo">Indigo</option>
+            <option value="violet"></option>
+        </select>
+    """
+    )
+    assert await page.locator("select").input_value() == "indigo"
+    await page.select_option("select", label="")
+    assert await page.locator("select").input_value() == "violet"
+
+
+async def test_select_option_should_select_single_option_by_handle(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.select_option(
+        "select", element=await page.query_selector("[id=whiteOption]")
+    )
+    assert await page.evaluate("result.onInput") == ["white"]
+    assert await page.evaluate("result.onChange") == ["white"]
+
+
+async def test_select_option_should_select_single_option_by_index(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.select_option("select", index=2)
+    assert await page.evaluate("result.onInput") == ["brown"]
+    assert await page.evaluate("result.onChange") == ["brown"]
+
+
+async def test_select_option_should_select_single_option_by_index_0(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.select_option("select", index=0)
+    assert await page.evaluate("result.onInput") == ["black"]
+
+
+async def test_select_option_should_select_only_first_option(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.select_option("select", ["blue", "green", "red"])
+    assert await page.evaluate("result.onInput") == ["blue"]
+    assert await page.evaluate("result.onChange") == ["blue"]
+
+
+async def test_select_option_should_not_throw_when_select_causes_navigation(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.eval_on_selector(
+        "select",
+        "select => select.addEventListener('input', () => window.location = '/empty.html')",
+    )
+    async with page.expect_navigation():
+        await page.select_option("select", "blue")
+    assert "empty.html" in page.url
+
+
+async def test_select_option_should_select_multiple_options(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.evaluate("makeMultiple()")
+    await page.select_option("select", ["blue", "green", "red"])
+    assert await page.evaluate("result.onInput") == ["blue", "green", "red"]
+    assert await page.evaluate("result.onChange") == ["blue", "green", "red"]
+
+
+async def test_select_option_should_select_multiple_options_with_attributes(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.evaluate("makeMultiple()")
+    await page.select_option(
+        "select",
+        value="blue",
+        label="Green",
+        index=4,
+    )
+    assert await page.evaluate("result.onInput") == ["blue", "gray", "green"]
+    assert await page.evaluate("result.onChange") == ["blue", "gray", "green"]
+
+
+async def test_select_option_should_select_option_with_empty_value(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content(
+        """
+        <select>
+            <option value="first">First</option>
+            <option value="">Second</option>
+        </select>
+    """
+    )
+    assert await page.locator("select").input_value() == "first"
+    await page.select_option("select", value="")
+    assert await page.locator("select").input_value() == ""
+
+
+async def test_select_option_should_respect_event_bubbling(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.select_option("select", "blue")
+    assert await page.evaluate("result.onBubblingInput") == ["blue"]
+    assert await page.evaluate("result.onBubblingChange") == ["blue"]
+
+
+async def test_select_option_should_throw_when_element_is_not_a__select_(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    with pytest.raises(Error) as exc_info:
+        await page.select_option("body", "")
+    assert "Element is not a <select> element" in exc_info.value.message
+
+
+async def test_select_option_should_return_on_no_matched_values(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    with pytest.raises(TimeoutError) as exc_info:
+        await page.select_option("select", ["42", "abc"], timeout=1000)
+    assert "Timeout 1000" in exc_info.value.message
+
+
+async def test_select_option_should_return_an_array_of_matched_values(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.evaluate("makeMultiple()")
+    result = await page.select_option("select", ["blue", "black", "magenta"])
+    assert result == ["black", "blue", "magenta"]
+
+
+async def test_select_option_should_return_an_array_of_one_element_when_multiple_is_not_set(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    result = await page.select_option("select", ["42", "blue", "black", "magenta"])
+    assert len(result) == 1
+
+
+async def test_select_option_should_return_on_no_values(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    result = await page.select_option("select", [])
+    assert result == []
+
+
+async def test_select_option_should_not_allow_null_items(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.evaluate("makeMultiple()")
+    with pytest.raises(Error) as exc_info:
+        await page.select_option("select", ["blue", None, "black", "magenta"])  # type: ignore
+    assert "expected string, got object" in exc_info.value.message
+
+
+async def test_select_option_should_unselect_with_null(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.evaluate("makeMultiple()")
+    result = await page.select_option("select", ["blue", "black", "magenta"])
+    assert result == ["black", "blue", "magenta"]
+    await page.select_option("select", None)
+    assert await page.eval_on_selector(
+        "select",
+        "select => Array.from(select.options).every(option => !option.selected)",
+    )
+
+
+async def test_select_option_should_deselect_all_options_when_passed_no_values_for_a_multiple_select(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.evaluate("makeMultiple()")
+    await page.select_option("select", ["blue", "black", "magenta"])
+    await page.select_option("select", [])
+    assert await page.eval_on_selector(
+        "select",
+        "select => Array.from(select.options).every(option => !option.selected)",
+    )
+
+
+async def test_select_option_should_deselect_all_options_when_passed_no_values_for_a_select_without_multiple(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.select_option("select", ["blue", "black", "magenta"])
+    await page.select_option("select", [])
+    assert await page.eval_on_selector(
+        "select",
+        "select => Array.from(select.options).every(option => !option.selected)",
+    )
+
+
+async def test_select_option_should_work_when_re_defining_top_level_event_class(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.evaluate("window.Event = null")
+    await page.select_option("select", "blue")
+    assert await page.evaluate("result.onInput") == ["blue"]
+    assert await page.evaluate("result.onChange") == ["blue"]
+
+
+async def test_select_options_should_fall_back_to_selecting_by_label(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.PREFIX + "/input/select.html")
+    await page.select_option("select", "Blue")
+    assert await page.evaluate("result.onInput") == ["blue"]
+    assert await page.evaluate("result.onChange") == ["blue"]
diff --git a/tests/async/test_pdf.py b/tests/async/test_pdf.py
index a94efb92f..93d1fcf8a 100644
--- a/tests/async/test_pdf.py
+++ b/tests/async/test_pdf.py
@@ -18,16 +18,30 @@
 import pytest
 
 from playwright.async_api import Page
+from tests.server import Server
 
+pytestmark = pytest.mark.only_browser("chromium")
 
-@pytest.mark.only_browser("chromium")
-async def test_should_be_able_to_save_pdf_file(page: Page, server, tmpdir: Path):
-    output_file = tmpdir / "foo.png"
+
+async def test_should_be_able_to_save_pdf_file(page: Page, tmp_path: Path) -> None:
+    output_file = tmp_path / "foo.png"
     await page.pdf(path=str(output_file))
     assert os.path.getsize(output_file) > 0
 
 
-@pytest.mark.only_browser("chromium")
-async def test_should_be_able_capture_pdf_without_path(page: Page):
+async def test_should_be_able_capture_pdf_without_path(page: Page) -> None:
     buffer = await page.pdf()
     assert buffer
+
+
+async def test_should_be_able_to_generate_outline(
+    page: Page, server: Server, tmp_path: Path
+) -> None:
+    await page.goto(server.PREFIX + "/headings.html")
+    output_file_no_outline = tmp_path / "outputNoOutline.pdf"
+    output_file_outline = tmp_path / "outputOutline.pdf"
+    await page.pdf(path=output_file_no_outline)
+    await page.pdf(path=output_file_outline, tagged=True, outline=True)
+    assert os.path.getsize(output_file_outline) > os.path.getsize(
+        output_file_no_outline
+    )
diff --git a/tests/async/test_popup.py b/tests/async/test_popup.py
index b92dbf19c..3c14b87f0 100644
--- a/tests/async/test_popup.py
+++ b/tests/async/test_popup.py
@@ -13,14 +13,18 @@
 # limitations under the License.
 
 import asyncio
-from typing import List, cast
+from typing import List, Optional
 
-from playwright.async_api import Browser, Page, Request, Route
+import pytest
+
+from playwright.async_api import Browser, BrowserContext, Request, Route
+from tests.server import Server
+from tests.utils import must
 
 
 async def test_link_navigation_inherit_user_agent_from_browser_context(
-    browser: Browser, server
-):
+    browser: Browser, server: Server
+) -> None:
     context = await browser.new_context(user_agent="hey")
 
     page = await context.new_page()
@@ -30,15 +34,9 @@ async def test_link_navigation_inherit_user_agent_from_browser_context(
     )
     request_waitable = asyncio.create_task(server.wait_for_request("/popup/popup.html"))
     await asyncio.sleep(0)  # execute scheduled tasks, but don't await them
-    popup = cast(
-        Page,
-        (
-            await asyncio.gather(
-                context.wait_for_event("page"),
-                page.click("a"),
-            )
-        )[0],
-    )
+    async with context.expect_page() as page_info:
+        await page.click("a")
+    popup = await page_info.value
     await popup.wait_for_load_state("domcontentloaded")
     user_agent = await popup.evaluate("window.initialUserAgent")
     request = await request_waitable
@@ -47,30 +45,28 @@ async def test_link_navigation_inherit_user_agent_from_browser_context(
     await context.close()
 
 
-async def test_link_navigation_respect_routes_from_browser_context(context, server):
+async def test_link_navigation_respect_routes_from_browser_context(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
     await page.set_content('<a target=_blank rel=noopener href="empty.html">link</a>')
 
-    def handle_request(route: Route, request: Request, intercepted) -> None:
-        asyncio.create_task(route.continue_())
+    intercepted: List[bool] = []
+
+    async def handle_request(route: Route) -> None:
         intercepted.append(True)
+        await route.continue_()
 
-    intercepted: List[bool] = []
-    await context.route(
-        "**/empty.html",
-        lambda route, request: handle_request(route, request, intercepted),
-    )
-    await asyncio.gather(
-        context.wait_for_event("page"),
-        page.click("a"),
-    )
+    await context.route("**/empty.html", handle_request)
+    async with context.expect_page():
+        await page.click("a")
     assert intercepted == [True]
 
 
 async def test_window_open_inherit_user_agent_from_browser_context(
-    browser: Browser, server
-):
+    browser: Browser, server: Server
+) -> None:
     context = await browser.new_context(user_agent="hey")
 
     page = await context.new_page()
@@ -91,8 +87,8 @@ async def test_window_open_inherit_user_agent_from_browser_context(
 
 
 async def test_should_inherit_extra_headers_from_browser_context(
-    browser: Browser, server
-):
+    browser: Browser, server: Server
+) -> None:
     context = await browser.new_context(extra_http_headers={"foo": "bar"})
 
     page = await context.new_page()
@@ -107,7 +103,9 @@ async def test_should_inherit_extra_headers_from_browser_context(
     await context.close()
 
 
-async def test_should_inherit_offline_from_browser_context(context, server):
+async def test_should_inherit_offline_from_browser_context(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
     await context.set_offline(True)
@@ -122,29 +120,34 @@ async def test_should_inherit_offline_from_browser_context(context, server):
 
 
 async def test_should_inherit_http_credentials_from_browser_context(
-    browser: Browser, server
-):
-    server.set_auth("/title.html", b"user", b"pass")
-    context = await browser.new_context(http_credentials=("user", "pass"))
+    browser: Browser, server: Server
+) -> None:
+    server.set_auth("/title.html", "user", "pass")
+    context = await browser.new_context(
+        http_credentials={"username": "user", "password": "pass"}
+    )
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.evaluate(
-                "url => window._popup = window.open(url)", server.PREFIX + "/title.html"
-            ),
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
+            "url => window._popup = window.open(url)", server.PREFIX + "/title.html"
         )
-    )[0]
+    popup = await popup_info.value
     await popup.wait_for_load_state("domcontentloaded")
     assert await popup.title() == "Woof-Woof"
     await context.close()
 
 
+@pytest.mark.skip_browser("firefox")
 async def test_should_inherit_touch_support_from_browser_context(
-    browser: Browser, server
-):
-    context = await browser.new_context(viewport=(400, 500), has_touch=True)
+    browser: Browser, server: Server
+) -> None:
+    # Firefox 148+ does not expose `ontouchstart` on freshly window.open()'d
+    # popups (https://bugzilla.mozilla.org/show_bug.cgi?id=2014330);
+    # upstream marks this as fixme for the same reason.
+    context = await browser.new_context(
+        viewport={"width": 400, "height": 500}, has_touch=True
+    )
 
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
@@ -160,9 +163,9 @@ async def test_should_inherit_touch_support_from_browser_context(
 
 
 async def test_should_inherit_viewport_size_from_browser_context(
-    browser: Browser, server
-):
-    context = await browser.new_context(viewport=(400, 500))
+    browser: Browser, server: Server
+) -> None:
+    context = await browser.new_context(viewport={"width": 400, "height": 500})
 
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
@@ -177,20 +180,30 @@ async def test_should_inherit_viewport_size_from_browser_context(
     await context.close()
 
 
-async def test_should_use_viewport_size_from_window_features(browser: Browser, server):
-    context = await browser.new_context(viewport=(700, 700))
+async def test_should_use_viewport_size_from_window_features(
+    browser: Browser, server: Server
+) -> None:
+    context = await browser.new_context(viewport={"width": 700, "height": 700})
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
-    [size, popup] = await asyncio.gather(
-        page.evaluate(
-            """() => {
-                win = window.open(window.location.href, 'Title', 'toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,width=600,height=300,top=0,left=0')
+    size = None
+    async with page.expect_popup() as popup_info:
+        size = await page.evaluate(
+            """async () => {
+                const win = window.open(window.location.href, 'Title', 'toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,width=600,height=300,top=0,left=0');
+                await new Promise(resolve => {
+                    const interval = setInterval(() => {
+                    if (win.innerWidth === 600 && win.innerHeight === 300) {
+                        clearInterval(interval);
+                        resolve();
+                    }
+                    }, 10);
+                });
                 return { width: win.innerWidth, height: win.innerHeight }
             }"""
-        ),
-        page.wait_for_event("popup"),
-    )
-    await popup.set_viewport_size(width=500, height=400)
+        )
+    popup = await popup_info.value
+    await popup.set_viewport_size({"width": 500, "height": 400})
     await popup.wait_for_load_state()
     resized = await popup.evaluate(
         "() => ({ width: window.innerWidth, height: window.innerHeight })"
@@ -200,30 +213,32 @@ async def test_should_use_viewport_size_from_window_features(browser: Browser, s
     assert resized == {"width": 500, "height": 400}
 
 
-async def test_should_respect_routes_from_browser_context(context, server):
+async def test_should_respect_routes_from_browser_context(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
 
-    def handle_request(route, request, intercepted):
+    def handle_request(route: Route, request: Request, intercepted: List[bool]) -> None:
         asyncio.create_task(route.continue_())
         intercepted.append(True)
 
-    intercepted = []
+    intercepted: List[bool] = []
     await context.route(
         "**/empty.html",
         lambda route, request: handle_request(route, request, intercepted),
     )
 
-    await asyncio.gather(
-        page.wait_for_event("popup"),
-        page.evaluate("url => window.__popup = window.open(url)", server.EMPTY_PAGE),
-    )
+    async with page.expect_popup():
+        await page.evaluate(
+            "url => window.__popup = window.open(url)", server.EMPTY_PAGE
+        )
     assert len(intercepted) == 1
 
 
 async def test_browser_context_add_init_script_should_apply_to_an_in_process_popup(
-    context, server
-):
+    context: BrowserContext, server: Server
+) -> None:
     await context.add_init_script("window.injected = 123")
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
@@ -238,25 +253,24 @@ async def test_browser_context_add_init_script_should_apply_to_an_in_process_pop
 
 
 async def test_browser_context_add_init_script_should_apply_to_a_cross_process_popup(
-    context, server
-):
+    context: BrowserContext, server: Server
+) -> None:
     await context.add_init_script("window.injected = 123")
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.evaluate(
-                "url => window.open(url)", server.CROSS_PROCESS_PREFIX + "/title.html"
-            ),
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
+            "url => window.open(url)", server.CROSS_PROCESS_PREFIX + "/title.html"
         )
-    )[0]
+    popup = await popup_info.value
     assert await popup.evaluate("injected") == 123
     await popup.reload()
     assert await popup.evaluate("injected") == 123
 
 
-async def test_should_expose_function_from_browser_context(context, server):
+async def test_should_expose_function_from_browser_context(
+    context: BrowserContext, server: Server
+) -> None:
     await context.expose_function("add", lambda a, b: a + b)
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
@@ -270,202 +284,192 @@ async def test_should_expose_function_from_browser_context(context, server):
     assert added == 13
 
 
-async def test_should_work(context):
+async def test_should_work(context: BrowserContext) -> None:
     page = await context.new_page()
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.evaluate('window.__popup = window.open("about:blank")'),
-        )
-    )[0]
+    async with page.expect_popup() as popup_info:
+        await page.evaluate('window.__popup = window.open("about:blank")')
+    popup = await popup_info.value
     assert await page.evaluate("!!window.opener") is False
     assert await popup.evaluate("!!window.opener")
 
 
-async def test_should_work_with_window_features(context, server):
+async def test_should_work_with_window_features(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.evaluate(
-                'window.__popup = window.open(window.location.href, "Title", "toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,width=780,height=200,top=0,left=0")'
-            ),
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
+            'window.__popup = window.open(window.location.href, "Title", "toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,width=780,height=200,top=0,left=0")'
         )
-    )[0]
+    popup = await popup_info.value
     assert await page.evaluate("!!window.opener") is False
     assert await popup.evaluate("!!window.opener")
 
 
-async def test_window_open_emit_for_immediately_closed_popups(context):
+async def test_window_open_emit_for_immediately_closed_popups(
+    context: BrowserContext,
+) -> None:
     page = await context.new_page()
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.evaluate(
-                """() => {
-                    win = window.open('about:blank')
-                    win.close()
-                }"""
-            ),
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
+            """() => {
+                win = window.open('about:blank')
+                win.close()
+            }"""
         )
-    )[0]
+    popup = await popup_info.value
     assert popup
 
 
-async def test_should_emit_for_immediately_closed_popups(context, server):
+async def test_should_emit_for_immediately_closed_popups(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.evaluate(
-                """() => {
-                    win = window.open(window.location.href)
-                    win.close()
-                }"""
-            ),
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
+            """() => {
+                win = window.open(window.location.href)
+                win.close()
+            }"""
         )
-    )[0]
+    popup = await popup_info.value
     assert popup
 
 
-async def test_should_be_able_to_capture_alert(context):
+async def test_should_be_able_to_capture_alert(context: BrowserContext) -> None:
     page = await context.new_page()
-    evaluate_promise = asyncio.create_task(
-        page.evaluate(
-            """() => {
+    evaluate_task: Optional[asyncio.Future] = None
+
+    async def evaluate() -> None:
+        nonlocal evaluate_task
+        evaluate_task = asyncio.create_task(
+            page.evaluate(
+                """() => {
                 const win = window.open('')
                 win.alert('hello')
             }"""
+            )
         )
+
+    [popup, dialog, _] = await asyncio.gather(
+        page.wait_for_event("popup"), context.wait_for_event("dialog"), evaluate()
     )
 
-    popup = await page.wait_for_event("popup")
-    dialog = await popup.wait_for_event("dialog")
     assert dialog.message == "hello"
+    assert dialog.page == popup
     await dialog.dismiss()
-    await evaluate_promise
+    await must(evaluate_task)
 
 
-async def test_should_work_with_empty_url(context):
+async def test_should_work_with_empty_url(context: BrowserContext) -> None:
     page = await context.new_page()
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.evaluate('() => window.__popup = window.open("")'),
-        )
-    )[0]
+    async with page.expect_popup() as popup_info:
+        await page.evaluate("() => window.__popup = window.open('')")
+    popup = await popup_info.value
     assert await page.evaluate("!!window.opener") is False
     assert await popup.evaluate("!!window.opener")
 
 
-async def test_should_work_with_noopener_and_no_url(context):
+async def test_should_work_with_noopener_and_no_url(context: BrowserContext) -> None:
     page = await context.new_page()
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.evaluate(
-                '() => window.__popup = window.open(undefined, null, "noopener")'
-            ),
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
+            '() => window.__popup = window.open(undefined, null, "noopener")'
         )
-    )[0]
+    popup = await popup_info.value
     # Chromium reports 'about:blank#blocked' here.
     assert popup.url.split("#")[0] == "about:blank"
     assert await page.evaluate("!!window.opener") is False
     assert await popup.evaluate("!!window.opener") is False
 
 
-async def test_should_work_with_noopener_and_about_blank(context):
+async def test_should_work_with_noopener_and_about_blank(
+    context: BrowserContext,
+) -> None:
     page = await context.new_page()
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.evaluate(
-                '() => window.__popup = window.open("about:blank", null, "noopener")'
-            ),
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
+            '() => window.__popup = window.open("about:blank", null, "noopener")'
         )
-    )[0]
+    popup = await popup_info.value
     assert await page.evaluate("!!window.opener") is False
     assert await popup.evaluate("!!window.opener") is False
 
 
-async def test_should_work_with_noopener_and_url(context, server):
+async def test_should_work_with_noopener_and_url(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.evaluate(
-                'url => window.__popup = window.open(url, null, "noopener")',
-                server.EMPTY_PAGE,
-            ),
+    async with page.expect_popup() as popup_info:
+        await page.evaluate(
+            'url => window.__popup = window.open(url, null, "noopener")',
+            server.EMPTY_PAGE,
         )
-    )[0]
+    popup = await popup_info.value
     assert await page.evaluate("!!window.opener") is False
     assert await popup.evaluate("!!window.opener") is False
 
 
-async def test_should_work_with_clicking_target__blank(context, server):
+async def test_should_work_with_clicking_target__blank(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
     await page.set_content(
         '<a target=_blank rel="opener" href="/one-style.html">yo</a>'
     )
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.click("a"),
-        )
-    )[0]
+    async with page.expect_popup() as popup_info:
+        await page.click("a")
+    popup = await popup_info.value
     assert await page.evaluate("!!window.opener") is False
     assert await popup.evaluate("!!window.opener")
+    assert popup.main_frame.page == popup
 
 
 async def test_should_work_with_fake_clicking_target__blank_and_rel_noopener(
-    context, server
-):
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
     await page.set_content(
         '<a target=_blank rel=noopener href="/one-style.html">yo</a>'
     )
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.eval_on_selector("a", "a => a.click()"),
-        )
-    )[0]
+    async with page.expect_popup() as popup_info:
+        await page.eval_on_selector("a", "a => a.click()")
+    popup = await popup_info.value
     assert await page.evaluate("!!window.opener") is False
     assert await popup.evaluate("!!window.opener") is False
 
 
 async def test_should_work_with_clicking_target__blank_and_rel_noopener(
-    context, server
-):
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
     await page.set_content(
         '<a target=_blank rel=noopener href="/one-style.html">yo</a>'
     )
-    popup = (
-        await asyncio.gather(
-            page.wait_for_event("popup"),
-            page.click("a"),
-        )
-    )[0]
+    async with page.expect_popup() as popup_info:
+        await page.click("a")
+    popup = await popup_info.value
     assert await page.evaluate("!!window.opener") is False
     assert await popup.evaluate("!!window.opener") is False
 
 
-async def test_should_not_treat_navigations_as_new_popups(context, server):
+async def test_should_not_treat_navigations_as_new_popups(
+    context: BrowserContext, server: Server
+) -> None:
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
     await page.set_content(
         '<a target=_blank rel=noopener href="/one-style.html">yo</a>'
     )
-    popup = (await asyncio.gather(page.wait_for_event("popup"), page.click("a")))[0]
-
+    async with page.expect_popup() as popup_info:
+        await page.click("a")
+    popup = await popup_info.value
     handled_popups = []
     page.on(
         "popup",
diff --git a/tests/async/test_proxy.py b/tests/async/test_proxy.py
new file mode 100644
index 000000000..694786aae
--- /dev/null
+++ b/tests/async/test_proxy.py
@@ -0,0 +1,160 @@
+# 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 asyncio
+import base64
+from typing import Callable
+
+import pytest
+
+from playwright.async_api import Browser, Error
+from tests.server import Server, TestServerRequest
+
+
+async def test_should_throw_for_bad_server_value(
+    browser_factory: "Callable[..., asyncio.Future[Browser]]",
+) -> None:
+    with pytest.raises(Error) as exc_info:
+        await browser_factory(proxy={"server": 123})
+    assert "proxy.server: expected string, got number" in exc_info.value.message
+
+
+async def test_should_use_proxy(
+    browser_factory: "Callable[..., asyncio.Future[Browser]]", server: Server
+) -> None:
+    server.set_route(
+        "/target.html",
+        lambda r: (
+            r.write(b"<html><title>Served by the proxy</title></html>"),
+            r.finish(),
+        ),
+    )
+    browser = await browser_factory(proxy={"server": f"localhost:{server.PORT}"})
+    page = await browser.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Served by the proxy"
+
+
+async def test_proxy_should_allow_none_for_optional_settings(
+    browser_factory: "Callable[..., asyncio.Future[Browser]]", server: Server
+) -> None:
+    server.set_route(
+        "/target.html",
+        lambda r: (
+            r.write(b"<html><title>Served by the proxy</title></html>"),
+            r.finish(),
+        ),
+    )
+    browser = await browser_factory(
+        proxy={
+            "server": f"localhost:{server.PORT}",
+            "username": None,
+            "password": None,
+            "bypass": None,
+        }
+    )
+    page = await browser.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Served by the proxy"
+
+
+async def test_should_use_proxy_for_second_page(
+    browser_factory: "Callable[..., asyncio.Future[Browser]]", server: Server
+) -> None:
+    server.set_route(
+        "/target.html",
+        lambda r: (
+            r.write(b"<html><title>Served by the proxy</title></html>"),
+            r.finish(),
+        ),
+    )
+    browser = await browser_factory(proxy={"server": f"localhost:{server.PORT}"})
+
+    page1 = await browser.new_page()
+    await page1.goto("http://non-existent.com/target.html")
+    assert await page1.title() == "Served by the proxy"
+
+    page2 = await browser.new_page()
+    await page2.goto("http://non-existent.com/target.html")
+    assert await page2.title() == "Served by the proxy"
+
+
+async def test_should_work_with_ip_port_notion(
+    browser_factory: "Callable[..., asyncio.Future[Browser]]", server: Server
+) -> None:
+    server.set_route(
+        "/target.html",
+        lambda r: (
+            r.write(b"<html><title>Served by the proxy</title></html>"),
+            r.finish(),
+        ),
+    )
+    browser = await browser_factory(proxy={"server": f"127.0.0.1:{server.PORT}"})
+    page = await browser.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Served by the proxy"
+
+
+async def test_should_authenticate(
+    browser_factory: "Callable[..., asyncio.Future[Browser]]", server: Server
+) -> None:
+    def handler(req: TestServerRequest) -> None:
+        auth = req.getHeader("proxy-authorization")
+        if not auth:
+            req.setHeader(
+                b"Proxy-Authenticate", b'Basic realm="Access to internal site"'
+            )
+            req.setResponseCode(407)
+        else:
+            req.write(f"<html><title>{auth}</title></html>".encode("utf-8"))
+        req.finish()
+
+    server.set_route("/target.html", handler)
+
+    browser = await browser_factory(
+        proxy={
+            "server": f"localhost:{server.PORT}",
+            "username": "user",
+            "password": "secret",
+        }
+    )
+    page = await browser.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Basic " + base64.b64encode(b"user:secret").decode(
+        "utf-8"
+    )
+
+
+async def test_should_authenticate_with_empty_password(
+    browser_factory: "Callable[..., asyncio.Future[Browser]]", server: Server
+) -> None:
+    def handler(req: TestServerRequest) -> None:
+        auth = req.getHeader("proxy-authorization")
+        if not auth:
+            req.setHeader(
+                b"Proxy-Authenticate", b'Basic realm="Access to internal site"'
+            )
+            req.setResponseCode(407)
+        else:
+            req.write(f"<html><title>{auth}</title></html>".encode("utf-8"))
+        req.finish()
+
+    server.set_route("/target.html", handler)
+
+    browser = await browser_factory(
+        proxy={"server": f"localhost:{server.PORT}", "username": "user", "password": ""}
+    )
+    page = await browser.new_page()
+    await page.goto("http://non-existent.com/target.html")
+    assert await page.title() == "Basic " + base64.b64encode(b"user:").decode("utf-8")
diff --git a/tests/async/test_queryselector.py b/tests/async/test_queryselector.py
index 30f0f1e25..28dd720d7 100644
--- a/tests/async/test_queryselector.py
+++ b/tests/async/test_queryselector.py
@@ -1,9 +1,28 @@
+# 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.
+from pathlib import Path
+
 import pytest
 
-from playwright.async_api import Error, Page
+from playwright.async_api import Browser, Error, Page, Selectors
+
+from .utils import Utils
 
 
-async def test_selectors_register_should_work(selectors, browser):
+async def test_selectors_register_should_work(
+    selectors: Selectors, browser: Browser, browser_name: str
+) -> None:
     tag_selector = """
         {
             create(root, target) {
@@ -17,23 +36,40 @@ async def test_selectors_register_should_work(selectors, browser):
             }
         }"""
 
+    selector_name = f"tag_{browser_name}"
+    selector2_name = f"tag2_{browser_name}"
+
     # Register one engine before creating context.
-    await selectors.register("tag", tag_selector)
+    await selectors.register(selector_name, tag_selector)
 
     context = await browser.new_context()
     # Register another engine after creating context.
-    await selectors.register("tag2", tag_selector)
+    await selectors.register(selector2_name, tag_selector)
 
     page = await context.new_page()
     await page.set_content("<div><span></span></div><div></div>")
 
-    assert await page.eval_on_selector("tag=DIV", "e => e.nodeName") == "DIV"
-    assert await page.eval_on_selector("tag=SPAN", "e => e.nodeName") == "SPAN"
-    assert await page.eval_on_selector_all("tag=DIV", "es => es.length") == 2
+    assert (
+        await page.eval_on_selector(f"{selector_name}=DIV", "e => e.nodeName") == "DIV"
+    )
+    assert (
+        await page.eval_on_selector(f"{selector_name}=SPAN", "e => e.nodeName")
+        == "SPAN"
+    )
+    assert (
+        await page.eval_on_selector_all(f"{selector_name}=DIV", "es => es.length") == 2
+    )
 
-    assert await page.eval_on_selector("tag2=DIV", "e => e.nodeName") == "DIV"
-    assert await page.eval_on_selector("tag2=SPAN", "e => e.nodeName") == "SPAN"
-    assert await page.eval_on_selector_all("tag2=DIV", "es => es.length") == 2
+    assert (
+        await page.eval_on_selector(f"{selector2_name}=DIV", "e => e.nodeName") == "DIV"
+    )
+    assert (
+        await page.eval_on_selector(f"{selector2_name}=SPAN", "e => e.nodeName")
+        == "SPAN"
+    )
+    assert (
+        await page.eval_on_selector_all(f"{selector2_name}=DIV", "es => es.length") == 2
+    )
 
     # Selector names are case-sensitive.
     with pytest.raises(Error) as exc:
@@ -44,8 +80,8 @@ async def test_selectors_register_should_work(selectors, browser):
 
 
 async def test_selectors_register_should_work_with_path(
-    selectors, page: Page, utils, assetdir
-):
+    selectors: Selectors, page: Page, utils: Utils, assetdir: Path
+) -> None:
     await utils.register_selector_engine(
         selectors, "foo", path=assetdir / "sectionselectorengine.js"
     )
@@ -54,8 +90,8 @@ async def test_selectors_register_should_work_with_path(
 
 
 async def test_selectors_register_should_work_in_main_and_isolated_world(
-    selectors, page: Page, utils
-):
+    selectors: Selectors, page: Page, utils: Utils
+) -> None:
     dummy_selector_script = """{
       create(root, target) { },
       query(root, selector) {
@@ -120,7 +156,9 @@ async def test_selectors_register_should_work_in_main_and_isolated_world(
     )
 
 
-async def test_selectors_register_should_handle_errors(selectors, page: Page, utils):
+async def test_selectors_register_should_handle_errors(
+    selectors: Selectors, page: Page, utils: Utils
+) -> None:
     with pytest.raises(Error) as exc:
         await page.query_selector("neverregister=ignored")
     assert (
@@ -136,7 +174,7 @@ async def test_selectors_register_should_handle_errors(selectors, page: Page, ut
         return root.querySelector('dummy');
       },
       queryAll(root, selector) {
-        return Array.from(root.querySelectorAll('dummy'));
+        return Array.from(root.query_selector_all('dummy'));
       }
     }"""
 
@@ -144,7 +182,7 @@ async def test_selectors_register_should_handle_errors(selectors, page: Page, ut
         await selectors.register("$", dummy_selector_engine_script)
     assert (
         exc.value.message
-        == "Selector engine name may only contain [a-zA-Z0-9_] characters"
+        == "Selectors.register: Selector engine name may only contain [a-zA-Z0-9_] characters"
     )
 
     # Selector names are case-sensitive.
@@ -157,8 +195,216 @@ async def test_selectors_register_should_handle_errors(selectors, page: Page, ut
 
     with pytest.raises(Error) as exc:
         await selectors.register("dummy", dummy_selector_engine_script)
-    assert exc.value.message == '"dummy" selector engine has been already registered'
+    assert (
+        exc.value.message
+        == 'Selectors.register: "dummy" selector engine has been already registered'
+    )
 
     with pytest.raises(Error) as exc:
         await selectors.register("css", dummy_selector_engine_script)
-    assert exc.value.message == '"css" is a predefined selector engine'
+    assert (
+        exc.value.message == 'Selectors.register: "css" is a predefined selector engine'
+    )
+
+
+async def test_should_work_with_layout_selectors(page: Page) -> None:
+    #        +--+  +--+
+    #        | 1|  | 2|
+    #        +--+  ++-++
+    #        | 3|   | 4|
+    #   +-------+  ++-++
+    #   |   0   |  | 5|
+    #   | +--+  +--+--+
+    #   | | 6|  | 7|
+    #   | +--+  +--+
+    #   |       |
+    #   O-------+
+    #           +--+
+    #           | 8|
+    #           +--++--+
+    #               | 9|
+    #               +--+
+
+    boxes = [
+        # x, y, width, height
+        [0, 0, 150, 150],
+        [100, 200, 50, 50],
+        [200, 200, 50, 50],
+        [100, 150, 50, 50],
+        [201, 150, 50, 50],
+        [200, 100, 50, 50],
+        [50, 50, 50, 50],
+        [150, 50, 50, 50],
+        [150, -51, 50, 50],
+        [201, -101, 50, 50],
+    ]
+    await page.set_content(
+        '<container style="width: 500px; height: 500px; position: relative;"></container>'
+    )
+    await page.eval_on_selector(
+        "container",
+        """(container, boxes) => {
+    for (let i = 0; i < boxes.length; i++) {
+      const div = document.createElement('div');
+      div.style.position = 'absolute';
+      div.style.overflow = 'hidden';
+      div.style.boxSizing = 'border-box';
+      div.style.border = '1px solid black';
+      div.id = 'id' + i;
+      div.textContent = 'id' + i;
+      const box = boxes[i];
+      div.style.left = box[0] + 'px';
+      // Note that top is a flipped y coordinate.
+      div.style.top = (250 - box[1] - box[3]) + 'px';
+      div.style.width = box[2] + 'px';
+      div.style.height = box[3] + 'px';
+      container.appendChild(div);
+      const span = document.createElement('span');
+      span.textContent = '' + i;
+      div.appendChild(span);
+    }
+  }""",
+        boxes,
+    )
+
+    assert await page.eval_on_selector("div:right-of(#id6)", "e => e.id") == "id7"
+    assert await page.eval_on_selector("div:right-of(#id1)", "e => e.id") == "id2"
+    assert await page.eval_on_selector("div:right-of(#id3)", "e => e.id") == "id4"
+    assert await page.query_selector("div:right-of(#id4)") is None
+    assert await page.eval_on_selector("div:right-of(#id0)", "e => e.id") == "id7"
+    assert await page.eval_on_selector("div:right-of(#id8)", "e => e.id") == "id9"
+    assert (
+        await page.eval_on_selector_all(
+            "div:right-of(#id3)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id4,id2,id5,id7,id8,id9"
+    )
+    assert (
+        await page.eval_on_selector_all(
+            "div:right-of(#id3, 50)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id2,id5,id7,id8"
+    )
+    assert (
+        await page.eval_on_selector_all(
+            "div:right-of(#id3, 49)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id7,id8"
+    )
+
+    assert await page.eval_on_selector("div:left-of(#id2)", "e => e.id") == "id1"
+    assert await page.query_selector("div:left-of(#id0)") is None
+    assert await page.eval_on_selector("div:left-of(#id5)", "e => e.id") == "id0"
+    assert await page.eval_on_selector("div:left-of(#id9)", "e => e.id") == "id8"
+    assert await page.eval_on_selector("div:left-of(#id4)", "e => e.id") == "id3"
+    assert (
+        await page.eval_on_selector_all(
+            "div:left-of(#id5)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0,id7,id3,id1,id6,id8"
+    )
+    assert (
+        await page.eval_on_selector_all(
+            "div:left-of(#id5, 3)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id7,id8"
+    )
+
+    assert await page.eval_on_selector("div:above(#id0)", "e => e.id") == "id3"
+    assert await page.eval_on_selector("div:above(#id5)", "e => e.id") == "id4"
+    assert await page.eval_on_selector("div:above(#id7)", "e => e.id") == "id5"
+    assert await page.eval_on_selector("div:above(#id8)", "e => e.id") == "id0"
+    assert await page.eval_on_selector("div:above(#id9)", "e => e.id") == "id8"
+    assert await page.query_selector("div:above(#id2)") is None
+    assert (
+        await page.eval_on_selector_all(
+            "div:above(#id5)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id4,id2,id3,id1"
+    )
+    assert (
+        await page.eval_on_selector_all(
+            "div:above(#id5, 20)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id4,id3"
+    )
+
+    assert await page.eval_on_selector("div:below(#id4)", "e => e.id") == "id5"
+    assert await page.eval_on_selector("div:below(#id3)", "e => e.id") == "id0"
+    assert await page.eval_on_selector("div:below(#id2)", "e => e.id") == "id4"
+    assert await page.eval_on_selector("div:below(#id6)", "e => e.id") == "id8"
+    assert await page.eval_on_selector("div:below(#id7)", "e => e.id") == "id8"
+    assert await page.eval_on_selector("div:below(#id8)", "e => e.id") == "id9"
+    assert await page.query_selector("div:below(#id9)") is None
+    assert (
+        await page.eval_on_selector_all(
+            "div:below(#id3)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0,id5,id6,id7,id8,id9"
+    )
+    assert (
+        await page.eval_on_selector_all(
+            "div:below(#id3, 105)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0,id5,id6,id7"
+    )
+
+    assert await page.eval_on_selector("div:near(#id0)", "e => e.id") == "id3"
+    assert (
+        await page.eval_on_selector_all(
+            "div:near(#id7)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0,id5,id3,id6"
+    )
+    assert (
+        await page.eval_on_selector_all(
+            "div:near(#id0)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id3,id6,id7,id8,id1,id5"
+    )
+    assert (
+        await page.eval_on_selector_all(
+            "div:near(#id6)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0,id3,id7"
+    )
+    assert (
+        await page.eval_on_selector_all(
+            "div:near(#id6, 10)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0"
+    )
+    assert (
+        await page.eval_on_selector_all(
+            "div:near(#id0, 100)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id3,id6,id7,id8,id1,id5,id4,id2"
+    )
+
+    assert (
+        await page.eval_on_selector_all(
+            "div:below(#id5):above(#id8)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id7,id6"
+    )
+    assert (
+        await page.eval_on_selector("div:below(#id5):above(#id8)", "e => e.id") == "id7"
+    )
+
+    assert (
+        await page.eval_on_selector_all(
+            "div:right-of(#id0) + div:above(#id8)",
+            "els => els.map(e => e.id).join(',')",
+        )
+        == "id5,id6,id3"
+    )
+
+    with pytest.raises(Error) as exc_info:
+        await page.query_selector(":near(50)")
+    assert (
+        '"near" engine expects a selector list and optional maximum distance in pixels'
+        in exc_info.value.message
+    )
+    with pytest.raises(Error) as exc_info:
+        await page.query_selector('left-of="div"')
+    assert '"left-of" selector cannot be first' in exc_info.value.message
diff --git a/tests/async/test_request_continue.py b/tests/async/test_request_continue.py
index 7a6eb322b..b322d01fb 100644
--- a/tests/async/test_request_continue.py
+++ b/tests/async/test_request_continue.py
@@ -13,14 +13,20 @@
 # limitations under the License.
 
 import asyncio
+from typing import Optional
 
+from playwright.async_api import Page, Route
+from tests.server import Server, TestServerRequest
 
-async def test_request_continue_should_work(page, server):
+
+async def test_request_continue_should_work(page: Page, server: Server) -> None:
     await page.route("**/*", lambda route: asyncio.create_task(route.continue_()))
     await page.goto(server.EMPTY_PAGE)
 
 
-async def test_request_continue_should_amend_http_headers(page, server):
+async def test_request_continue_should_amend_http_headers(
+    page: Page, server: Server
+) -> None:
     await page.route(
         "**/*",
         lambda route: asyncio.create_task(
@@ -36,7 +42,7 @@ async def test_request_continue_should_amend_http_headers(page, server):
     assert request.getHeader("foo") == "bar"
 
 
-async def test_request_continue_should_amend_method(page, server):
+async def test_request_continue_should_amend_method(page: Page, server: Server) -> None:
     server_request = asyncio.create_task(server.wait_for_request("/sleep.zzz"))
     await page.goto(server.EMPTY_PAGE)
     await page.route(
@@ -50,7 +56,9 @@ async def test_request_continue_should_amend_method(page, server):
     assert (await server_request).method.decode() == "POST"
 
 
-async def test_request_continue_should_amend_method_on_main_request(page, server):
+async def test_request_continue_should_amend_method_on_main_request(
+    page: Page, server: Server
+) -> None:
     request = asyncio.create_task(server.wait_for_request("/empty.html"))
     await page.route(
         "**/*", lambda route: asyncio.create_task(route.continue_(method="POST"))
@@ -59,7 +67,9 @@ async def test_request_continue_should_amend_method_on_main_request(page, server
     assert (await request).method.decode() == "POST"
 
 
-async def test_request_continue_should_amend_post_data(page, server):
+async def test_request_continue_should_amend_post_data(
+    page: Page, server: Server
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.route(
         "**/*",
@@ -74,10 +84,11 @@ async def test_request_continue_should_amend_post_data(page, server):
             """
         ),
     )
+    assert server_request.post_body
     assert server_request.post_body.decode() == "doggo"
 
 
-async def test_should_override_request_url(page, server):
+async def test_should_override_request_url(page: Page, server: Server) -> None:
     request = asyncio.create_task(server.wait_for_request("/empty.html"))
     await page.route(
         "**/foo",
@@ -88,7 +99,22 @@ async def test_should_override_request_url(page, server):
     assert (await request).method == b"GET"
 
 
-async def test_should_amend_utf8_post_data(page, server):
+async def test_should_raise_except(page: Page, server: Server) -> None:
+    exc_fut: "asyncio.Future[Optional[Exception]]" = asyncio.Future()
+
+    async def capture_exception(route: Route) -> None:
+        try:
+            await route.continue_(url="file:///tmp/does-not-exist")
+            exc_fut.set_result(None)
+        except Exception as e:
+            exc_fut.set_result(e)
+
+    await page.route("**/*", capture_exception)
+    asyncio.create_task(page.goto(server.EMPTY_PAGE))
+    assert "New URL must have same protocol as overridden URL" in str(await exc_fut)
+
+
+async def test_should_amend_utf8_post_data(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.route(
         "**/*",
@@ -100,10 +126,11 @@ async def test_should_amend_utf8_post_data(page, server):
         page.evaluate("fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })"),
     )
     assert server_request.method == b"POST"
+    assert server_request.post_body
     assert server_request.post_body.decode("utf8") == "пушкин"
 
 
-async def test_should_amend_binary_post_data(page, server):
+async def test_should_amend_binary_post_data(page: Page, server: Server) -> None:
     await page.goto(server.EMPTY_PAGE)
     await page.route(
         "**/*",
@@ -118,3 +145,52 @@ async def test_should_amend_binary_post_data(page, server):
     )
     assert server_request.method == b"POST"
     assert server_request.post_body == b"\x00\x01\x02\x03\x04"
+
+
+async def test_continue_should_not_change_multipart_form_data_body(
+    page: Page, server: Server, browser_name: str
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    server.set_route(
+        "/upload",
+        lambda context: (
+            context.write(b"done"),
+            context.setHeader("Content-Type", "text/plain"),
+            context.finish(),
+        ),
+    )
+
+    async def send_form_data() -> TestServerRequest:
+        req_task = asyncio.create_task(server.wait_for_request("/upload"))
+        status = await page.evaluate(
+            """async () => {
+            const newFile = new File(['file content'], 'file.txt');
+            const formData = new FormData();
+            formData.append('file', newFile);
+            const response = await fetch('/upload', {
+                method: 'POST',
+                credentials: 'include',
+                body: formData,
+            });
+            return response.status;
+        }"""
+        )
+        req = await req_task
+        assert status == 200
+        return req
+
+    req_before = await send_form_data()
+    await page.route("**/*", lambda route: route.continue_())
+    req_after = await send_form_data()
+
+    file_content = (
+        'Content-Disposition: form-data; name="file"; filename="file.txt"\r\n'
+        "Content-Type: application/octet-stream\r\n"
+        "\r\n"
+        "file content\r\n"
+        "------"
+    )
+    assert req_before.post_body
+    assert req_after.post_body
+    assert file_content in req_before.post_body.decode()
+    assert file_content in req_after.post_body.decode()
diff --git a/tests/async/test_request_fulfill.py b/tests/async/test_request_fulfill.py
new file mode 100644
index 000000000..854db7b57
--- /dev/null
+++ b/tests/async/test_request_fulfill.py
@@ -0,0 +1,75 @@
+# 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.
+
+from playwright.async_api import Page, Route
+from tests.server import Server
+
+
+async def test_should_fetch_original_request_and_fulfill(
+    page: Page, server: Server
+) -> None:
+    async def handle(route: Route) -> None:
+        response = await page.request.fetch(route.request)
+        await route.fulfill(response=response)
+
+    await page.route("**/*", handle)
+    response = await page.goto(server.PREFIX + "/title.html")
+    assert response
+    assert response.status == 200
+    assert await page.title() == "Woof-Woof"
+
+
+async def test_should_fulfill_json(page: Page, server: Server) -> None:
+    async def handle(route: Route) -> None:
+        await route.fulfill(status=201, headers={"foo": "bar"}, json={"bar": "baz"})
+
+    await page.route("**/*", handle)
+
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 201
+    assert response.headers["content-type"] == "application/json"
+    assert await response.json() == {"bar": "baz"}
+
+
+async def test_should_fulfill_json_overriding_existing_response(
+    page: Page, server: Server
+) -> None:
+    server.set_route(
+        "/tags",
+        lambda request: (
+            request.setHeader("foo", "bar"),
+            request.write('{"tags": ["a", "b"]}'.encode()),
+            request.finish(),
+        ),
+    )
+
+    original = {}
+
+    async def handle(route: Route) -> None:
+        response = await route.fetch()
+        json = await response.json()
+        original["tags"] = json["tags"]
+        json["tags"] = ["c"]
+        await route.fulfill(response=response, json=json)
+
+    await page.route("**/*", handle)
+
+    response = await page.goto(server.PREFIX + "/tags")
+    assert response
+    assert response.status == 200
+    assert response.headers["content-type"] == "application/json"
+    assert response.headers["foo"] == "bar"
+    assert original["tags"] == ["a", "b"]
+    assert await response.json() == {"tags": ["c"]}
diff --git a/tests/async/test_request_intercept.py b/tests/async/test_request_intercept.py
new file mode 100644
index 000000000..75746bbca
--- /dev/null
+++ b/tests/async/test_request_intercept.py
@@ -0,0 +1,191 @@
+# 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 asyncio
+from pathlib import Path
+
+from twisted.web import http
+
+from playwright.async_api import Page, Route
+from tests.server import Server
+
+
+async def test_should_fulfill_intercepted_response(page: Page, server: Server) -> None:
+    async def handle(route: Route) -> None:
+        response = await page.request.fetch(route.request)
+        await route.fulfill(
+            response=response,
+            status=201,
+            headers={"foo": "bar"},
+            content_type="text/plain",
+            body="Yo, page!",
+        )
+
+    await page.route("**/*", handle)
+    response = await page.goto(server.PREFIX + "/empty.html")
+    assert response
+    assert response.status == 201
+    assert response.headers["foo"] == "bar"
+    assert response.headers["content-type"] == "text/plain"
+    assert await page.evaluate("() => document.body.textContent") == "Yo, page!"
+
+
+async def test_should_fulfill_response_with_empty_body(
+    page: Page, server: Server
+) -> None:
+    async def handle(route: Route) -> None:
+        response = await page.request.fetch(route.request)
+        await route.fulfill(
+            response=response, status=201, body="", headers={"content-length": "0"}
+        )
+
+    await page.route("**/*", handle)
+    response = await page.goto(server.PREFIX + "/title.html")
+    assert response
+    assert response.status == 201
+    assert await response.text() == ""
+
+
+async def test_should_override_with_defaults_when_intercepted_response_not_provided(
+    page: Page, server: Server, browser_name: str
+) -> None:
+    def server_handler(request: http.Request) -> None:
+        request.setHeader("foo", "bar")
+        request.write("my content".encode())
+        request.finish()
+
+    server.set_route("/empty.html", server_handler)
+
+    async def handle(route: Route) -> None:
+        await page.request.fetch(route.request)
+        await route.fulfill(status=201)
+
+    await page.route("**/*", handle)
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 201
+    assert await response.text() == ""
+    if browser_name == "webkit":
+        assert response.headers == {"content-type": "text/plain"}
+    else:
+        assert response.headers == {}
+
+
+async def test_should_fulfill_with_any_response(page: Page, server: Server) -> None:
+    def server_handler(request: http.Request) -> None:
+        request.setHeader("foo", "bar")
+        request.write("Woo-hoo".encode())
+        request.finish()
+
+    server.set_route("/sample", server_handler)
+    sample_response = await page.request.get(server.PREFIX + "/sample")
+    await page.route(
+        "**/*",
+        lambda route: route.fulfill(
+            response=sample_response, status=201, content_type="text/plain"
+        ),
+    )
+    response = await page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 201
+    assert await response.text() == "Woo-hoo"
+    assert response.headers["foo"] == "bar"
+
+
+async def test_should_support_fulfill_after_intercept(
+    page: Page, server: Server, assetdir: Path
+) -> None:
+    request_future = asyncio.create_task(server.wait_for_request("/title.html"))
+
+    async def handle_route(route: Route) -> None:
+        response = await page.request.fetch(route.request)
+        await route.fulfill(response=response)
+
+    await page.route("**", handle_route)
+    response = await page.goto(server.PREFIX + "/title.html")
+    assert response
+    request = await request_future
+    assert request.uri.decode() == "/title.html"
+    original = (assetdir / "title.html").read_text()
+    assert await response.text() == original
+
+
+async def test_should_give_access_to_the_intercepted_response(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    route_task: "asyncio.Future[Route]" = asyncio.Future()
+    await page.route("**/title.html", lambda route: route_task.set_result(route))
+
+    eval_task = asyncio.create_task(
+        page.evaluate("url => fetch(url)", server.PREFIX + "/title.html")
+    )
+
+    route = await route_task
+    response = await page.request.fetch(route.request)
+
+    assert response.status == 200
+    assert response.status_text == "OK"
+    assert response.ok is True
+    assert response.url.endswith("/title.html") is True
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert list(
+        filter(
+            lambda header: header["name"].lower() == "content-type",
+            response.headers_array,
+        )
+    ) == [{"name": "Content-Type", "value": "text/html; charset=utf-8"}]
+
+    await asyncio.gather(
+        route.fulfill(response=response),
+        eval_task,
+    )
+
+
+async def test_should_give_access_to_the_intercepted_response_body(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    route_task: "asyncio.Future[Route]" = asyncio.Future()
+    await page.route("**/simple.json", lambda route: route_task.set_result(route))
+
+    eval_task = asyncio.create_task(
+        page.evaluate("url => fetch(url)", server.PREFIX + "/simple.json")
+    )
+
+    route = await route_task
+    response = await page.request.fetch(route.request)
+
+    assert await response.text() == '{"foo": "bar"}\n'
+
+    await asyncio.gather(
+        route.fulfill(response=response),
+        eval_task,
+    )
+
+
+async def test_should_intercept_by_glob(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.route(
+        "http://localhos**?*oo",
+        lambda route: route.fulfill(body="intercepted", status=200),
+    )
+
+    result = await page.evaluate(
+        "url => fetch(url).then(r => r.text())", server.PREFIX + "/?foo"
+    )
+
+    assert result == "intercepted"
diff --git a/tests/async/test_resource_timing.py b/tests/async/test_resource_timing.py
index f953818cf..e764e3159 100644
--- a/tests/async/test_resource_timing.py
+++ b/tests/async/test_resource_timing.py
@@ -12,79 +12,58 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
 import pytest
 
+from playwright.async_api import Browser, Page, ResourceTiming
+from tests.server import Server
 
-async def test_should_work(page, server, is_webkit, is_mac):
-    if is_webkit and is_mac:
-        pytest.skip()
+
+async def test_should_work(page: Page, server: Server) -> None:
     async with page.expect_event("requestfinished") as request_info:
         await page.goto(server.EMPTY_PAGE)
     request = await request_info.value
     timing = request.timing
-    assert timing["domainLookupStart"] >= 0
-    assert timing["domainLookupEnd"] >= timing["domainLookupStart"]
-    assert timing["connectStart"] >= timing["domainLookupEnd"]
-    assert timing["secureConnectionStart"] == -1
-    assert timing["connectEnd"] > timing["secureConnectionStart"]
+    verify_connections_timing_consistency(timing)
     assert timing["requestStart"] >= timing["connectEnd"]
-    assert timing["responseStart"] > timing["requestStart"]
+    assert timing["responseStart"] >= timing["requestStart"]
     assert timing["responseEnd"] >= timing["responseStart"]
     assert timing["responseEnd"] < 10000
 
 
-async def test_should_work_for_subresource(page, server, is_win, is_mac, is_webkit):
-    if is_webkit and is_win:
+async def test_should_work_for_subresource(
+    page: Page, server: Server, is_win: bool, is_mac: bool, is_webkit: bool
+) -> None:
+    if is_webkit and (is_mac or is_win):
         pytest.skip()
     requests = []
     page.on("requestfinished", lambda request: requests.append(request))
     await page.goto(server.PREFIX + "/one-style.html")
-    assert len(requests) == 2
+    assert len(requests) >= 2
     timing = requests[1].timing
-    if is_webkit and is_win:
-        # Curl does not reuse connections.
-        assert timing["domainLookupStart"] >= 0
-        assert timing["domainLookupEnd"] >= timing["domainLookupStart"]
-        assert timing["connectStart"] >= timing["domainLookupEnd"]
-        assert timing["secureConnectionStart"] == -1
-        assert timing["connectEnd"] > timing["secureConnectionStart"]
-    else:
-        assert timing["domainLookupStart"] == 0 or timing["domainLookupStart"] == -1
-        assert timing["domainLookupEnd"] == 0 or timing["domainLookupEnd"] == -1
-        assert timing["connectStart"] == 0 or timing["connectStart"] == -1
-        assert timing["connectEnd"] == 0 or timing["connectEnd"] == -1
-        assert timing["secureConnectionStart"] == -1
-
+    verify_connections_timing_consistency(timing)
     assert timing["requestStart"] >= 0
     assert timing["responseStart"] > timing["requestStart"]
     assert timing["responseEnd"] >= timing["responseStart"]
     assert timing["responseEnd"] < 10000
 
 
-async def test_should_work_for_ssl(browser, https_server, is_mac, is_webkit):
-    if is_webkit and is_mac:
-        pytest.skip()
+async def test_should_work_for_ssl(browser: Browser, https_server: Server) -> None:
     page = await browser.new_page(ignore_https_errors=True)
     async with page.expect_event("requestfinished") as request_info:
         await page.goto(https_server.EMPTY_PAGE)
     request = await request_info.value
     timing = request.timing
-    if not (is_webkit and is_mac):
-        assert timing["domainLookupStart"] >= 0
-        assert timing["domainLookupEnd"] >= timing["domainLookupStart"]
-        assert timing["connectStart"] >= timing["domainLookupEnd"]
-        assert timing["secureConnectionStart"] > timing["connectStart"]
-        assert timing["connectEnd"] > timing["secureConnectionStart"]
-        assert timing["requestStart"] >= timing["connectEnd"]
-
-    assert timing["responseStart"] > timing["requestStart"]
+    verify_connections_timing_consistency(timing)
+    assert timing["requestStart"] >= timing["connectEnd"]
+    assert timing["responseStart"] >= timing["requestStart"]
     assert timing["responseEnd"] >= timing["responseStart"]
     assert timing["responseEnd"] < 10000
     await page.close()
 
 
 @pytest.mark.skip_browser("webkit")  # In WebKit, redirects don"t carry the timing info
-async def test_should_work_for_redirect(page, server):
+async def test_should_work_for_redirect(page: Page, server: Server) -> None:
     server.set_redirect("/foo.html", "/empty.html")
     responses = []
     page.on("response", lambda response: responses.append(response))
@@ -97,23 +76,27 @@ async def test_should_work_for_redirect(page, server):
     assert responses[1].url == server.PREFIX + "/empty.html"
 
     timing1 = responses[0].request.timing
-    assert timing1["domainLookupStart"] >= 0
-    assert timing1["domainLookupEnd"] >= timing1["domainLookupStart"]
-    assert timing1["connectStart"] >= timing1["domainLookupEnd"]
-    assert timing1["secureConnectionStart"] == -1
-    assert timing1["connectEnd"] > timing1["secureConnectionStart"]
+    verify_connections_timing_consistency(timing1)
     assert timing1["requestStart"] >= timing1["connectEnd"]
     assert timing1["responseStart"] > timing1["requestStart"]
     assert timing1["responseEnd"] >= timing1["responseStart"]
     assert timing1["responseEnd"] < 10000
 
     timing2 = responses[1].request.timing
-    assert timing2["domainLookupStart"] == -1
-    assert timing2["domainLookupEnd"] == -1
-    assert timing2["connectStart"] == -1
-    assert timing2["secureConnectionStart"] == -1
-    assert timing2["connectEnd"] == -1
+    verify_connections_timing_consistency(timing2)
     assert timing2["requestStart"] >= 0
     assert timing2["responseStart"] > timing2["requestStart"]
     assert timing2["responseEnd"] >= timing2["responseStart"]
     assert timing2["responseEnd"] < 10000
+
+
+def verify_timing_value(value: float, previous: float) -> None:
+    assert value == -1 or value > 0 and value >= previous
+
+
+def verify_connections_timing_consistency(timing: ResourceTiming) -> None:
+    verify_timing_value(timing["domainLookupStart"], -1)
+    verify_timing_value(timing["domainLookupEnd"], timing["domainLookupStart"])
+    verify_timing_value(timing["connectStart"], timing["domainLookupEnd"])
+    verify_timing_value(timing["secureConnectionStart"], timing["connectStart"])
+    verify_timing_value(timing["connectEnd"], timing["secureConnectionStart"])
diff --git a/tests/async/test_route_web_socket.py b/tests/async/test_route_web_socket.py
new file mode 100644
index 000000000..da6ce8757
--- /dev/null
+++ b/tests/async/test_route_web_socket.py
@@ -0,0 +1,381 @@
+# 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 asyncio
+import re
+from typing import Any, Awaitable, Callable, Literal, Tuple, Union
+
+from playwright.async_api import Frame, Page, WebSocketRoute
+from playwright.async_api._generated import Browser
+from tests.server import Server, WebSocketProtocol
+
+
+async def assert_equal(
+    actual_cb: Callable[[], Union[Any, Awaitable[Any]]], expected: Any
+) -> None:
+    __tracebackhide__ = True
+    start_time = asyncio.get_event_loop().time()
+    attempts = 0
+    while True:
+        actual = actual_cb()
+        if asyncio.iscoroutine(actual):
+            actual = await actual
+        if actual == expected:
+            return
+        attempts += 1
+        if asyncio.get_event_loop().time() - start_time > 5:
+            raise TimeoutError(f"Timed out after 10 seconds. Last actual was: {actual}")
+        await asyncio.sleep(0.2)
+
+
+async def setup_ws(
+    target: Union[Page, Frame],
+    server: Server,
+    protocol: Union[Literal["blob"], Literal["arraybuffer"]],
+) -> None:
+    await target.goto(server.EMPTY_PAGE)
+    await target.evaluate(
+        """({ port, binaryType }) => {
+    window.log = [];
+    window.ws = new WebSocket('ws://localhost:' + port + '/ws');
+    window.ws.binaryType = binaryType;
+    window.ws.addEventListener('open', () => window.log.push('open'));
+    window.ws.addEventListener('close', event => window.log.push(`close code=${event.code} reason=${event.reason} wasClean=${event.wasClean}`));
+    window.ws.addEventListener('error', event => window.log.push(`error`));
+    window.ws.addEventListener('message', async event => {
+      let data;
+      if (typeof event.data === 'string')
+        data = event.data;
+      else if (event.data instanceof Blob)
+        data = 'blob:' + await event.data.text();
+      else
+        data = 'arraybuffer:' + await (new Blob([event.data])).text();
+      window.log.push(`message: data=${data} origin=${event.origin} lastEventId=${event.lastEventId}`);
+    });
+    window.wsOpened = new Promise(f => window.ws.addEventListener('open', () => f()));
+  }""",
+        {"port": server.PORT, "binaryType": protocol},
+    )
+
+
+async def test_should_work_with_ws_close(page: Page, server: Server) -> None:
+    future: asyncio.Future[WebSocketRoute] = asyncio.Future()
+
+    def _handle_ws(ws: WebSocketRoute) -> None:
+        ws.connect_to_server()
+        future.set_result(ws)
+
+    await page.route_web_socket(re.compile(".*"), _handle_ws)
+
+    ws_task = server.wait_for_web_socket()
+    await setup_ws(page, server, "blob")
+    ws = await ws_task
+
+    route = await future
+    route.send("hello")
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=hello origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    closed_promise: asyncio.Future[Tuple[int, str]] = asyncio.Future()
+    ws.events.once(
+        "close", lambda code, reason: closed_promise.set_result((code, reason))
+    )
+    await route.close(code=3009, reason="oops")
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=hello origin=ws://localhost:{server.PORT} lastEventId=",
+            "close code=3009 reason=oops wasClean=true",
+        ],
+    )
+    assert await closed_promise == (3009, "oops")
+
+
+async def test_should_pattern_match(page: Page, server: Server) -> None:
+    await page.route_web_socket(
+        re.compile(r".*/ws$"), lambda ws: ws.connect_to_server()
+    )
+    await page.route_web_socket(
+        "**/mock-ws", lambda ws: ws.on_message(lambda message: ws.send("mock-response"))
+    )
+
+    ws_task = server.wait_for_web_socket()
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate(
+        """async ({ port }) => {
+        window.log = [];
+        window.ws1 = new WebSocket('ws://localhost:' + port + '/ws');
+        window.ws1.addEventListener('message', event => window.log.push(`ws1:${event.data}`));
+        window.ws2 = new WebSocket('ws://localhost:' + port + '/something/something/mock-ws');
+        window.ws2.addEventListener('message', event => window.log.push(`ws2:${event.data}`));
+        await Promise.all([
+            new Promise(f => window.ws1.addEventListener('open', f)),
+            new Promise(f => window.ws2.addEventListener('open', f)),
+        ]);
+    }""",
+        {"port": server.PORT},
+    )
+
+    ws = await ws_task
+    ws.events.on("message", lambda payload, isBinary: ws.sendMessage(b"response"))
+
+    await page.evaluate("window.ws1.send('request')")
+    await assert_equal(lambda: page.evaluate("window.log"), ["ws1:response"])
+
+    await page.evaluate("window.ws2.send('request')")
+    await assert_equal(
+        lambda: page.evaluate("window.log"), ["ws1:response", "ws2:mock-response"]
+    )
+
+
+async def test_should_work_with_server(page: Page, server: Server) -> None:
+    future: asyncio.Future[WebSocketRoute] = asyncio.Future()
+
+    async def _handle_ws(ws: WebSocketRoute) -> None:
+        server = ws.connect_to_server()
+
+        def _ws_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-respond":
+                ws.send("response")
+                return
+            if message == "to-block":
+                return
+            if message == "to-modify":
+                server.send("modified")
+                return
+            server.send(message)
+
+        ws.on_message(_ws_on_message)
+
+        def _server_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-block":
+                return
+            if message == "to-modify":
+                ws.send("modified")
+                return
+            ws.send(message)
+
+        server.on_message(_server_on_message)
+        server.send("fake")
+        future.set_result(ws)
+
+    await page.route_web_socket(re.compile(".*"), _handle_ws)
+    ws_task = server.wait_for_web_socket()
+    log = []
+
+    def _once_web_socket_connection(ws: WebSocketProtocol) -> None:
+        ws.events.on(
+            "message", lambda data, is_binary: log.append(f"message: {data.decode()}")
+        )
+        ws.events.on(
+            "close",
+            lambda code, reason: log.append(f"close: code={code} reason={reason}"),
+        )
+
+    server.once_web_socket_connection(_once_web_socket_connection)
+
+    await setup_ws(page, server, "blob")
+    ws = await ws_task
+    await assert_equal(lambda: log, ["message: fake"])
+
+    ws.sendMessage(b"to-modify")
+    ws.sendMessage(b"to-block")
+    ws.sendMessage(b"pass-server")
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    await page.evaluate(
+        """() => {
+        window.ws.send('to-respond');
+        window.ws.send('to-modify');
+        window.ws.send('to-block');
+        window.ws.send('pass-client');
+    }"""
+    )
+    await assert_equal(
+        lambda: log, ["message: fake", "message: modified", "message: pass-client"]
+    )
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    route = await future
+    route.send("another")
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=another origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    await page.evaluate(
+        """() => {
+        window.ws.send('pass-client-2');
+    }"""
+    )
+    await assert_equal(
+        lambda: log,
+        [
+            "message: fake",
+            "message: modified",
+            "message: pass-client",
+            "message: pass-client-2",
+        ],
+    )
+
+    await page.evaluate(
+        """() => {
+        window.ws.close(3009, 'problem');
+    }"""
+    )
+    await assert_equal(
+        lambda: log,
+        [
+            "message: fake",
+            "message: modified",
+            "message: pass-client",
+            "message: pass-client-2",
+            "close: code=3009 reason=problem",
+        ],
+    )
+
+
+async def test_should_work_without_server(page: Page, server: Server) -> None:
+    future: asyncio.Future[WebSocketRoute] = asyncio.Future()
+
+    async def _handle_ws(ws: WebSocketRoute) -> None:
+        def _ws_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-respond":
+                ws.send("response")
+
+        ws.on_message(_ws_on_message)
+        future.set_result(ws)
+
+    await page.route_web_socket(re.compile(".*"), _handle_ws)
+    await setup_ws(page, server, "blob")
+
+    await page.evaluate(
+        """async () => {
+        await window.wsOpened;
+        window.ws.send('to-respond');
+        window.ws.send('to-block');
+        window.ws.send('to-respond');
+    }"""
+    )
+
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    route = await future
+    route.send("another")
+    # wait for the message to be processed
+    await page.wait_for_timeout(100)
+    await route.close(code=3008, reason="oops")
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=another origin=ws://localhost:{server.PORT} lastEventId=",
+            "close code=3008 reason=oops wasClean=true",
+        ],
+    )
+
+
+async def test_should_work_with_base_url(browser: Browser, server: Server) -> None:
+    context = await browser.new_context(base_url=f"http://localhost:{server.PORT}")
+    page = await context.new_page()
+
+    async def _handle_ws(ws: WebSocketRoute) -> None:
+        ws.on_message(lambda message: ws.send(message))
+
+    await page.route_web_socket("/ws", _handle_ws)
+    await setup_ws(page, server, "blob")
+
+    await page.evaluate(
+        """async () => {
+        await window.wsOpened;
+        window.ws.send('echo');
+    }"""
+    )
+
+    await assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=echo origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+
+async def test_should_work_with_no_trailing_slash(page: Page, server: Server) -> None:
+    log: list[str] = []
+
+    async def handle_ws(ws: WebSocketRoute) -> None:
+        def on_message(message: Union[str, bytes]) -> None:
+            assert isinstance(message, str)
+            log.append(message)
+            ws.send("response")
+
+        ws.on_message(on_message)
+
+    # No trailing slash in the route pattern
+    await page.route_web_socket(f"ws://localhost:{server.PORT}", handle_ws)
+
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate(
+        """({ port }) => {
+            window.log = [];
+            // No trailing slash in WebSocket URL
+            window.ws = new WebSocket('ws://localhost:' + port);
+            window.ws.addEventListener('message', event => window.log.push(event.data));
+        }""",
+        {"port": server.PORT},
+    )
+
+    await assert_equal(
+        lambda: page.evaluate("window.ws.readyState"), 1  # WebSocket.OPEN
+    )
+    await page.evaluate("window.ws.send('query')")
+    await assert_equal(lambda: log, ["query"])
+    await assert_equal(lambda: page.evaluate("window.log"), ["response"])
diff --git a/tests/async/test_screencast.py b/tests/async/test_screencast.py
new file mode 100644
index 000000000..5532f7847
--- /dev/null
+++ b/tests/async/test_screencast.py
@@ -0,0 +1,72 @@
+# 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 asyncio
+
+import pytest
+
+from playwright.async_api import Page, ScreencastFrame
+from tests.server import Server
+
+
+async def test_should_expose_screencast_property(page: Page) -> None:
+    assert page.screencast is page.screencast
+
+
+async def test_start_should_deliver_frames_via_callback(
+    page: Page, server: Server
+) -> None:
+    received: list = []
+    event = asyncio.Event()
+
+    def on_frame(frame: ScreencastFrame) -> None:
+        received.append(frame["data"])
+        event.set()
+
+    await page.screencast.start(on_frame=on_frame)
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate("() => document.body.style.backgroundColor = 'red'")
+    # Force a couple of paint cycles so engines that only emit on visual change
+    # still produce a frame. Mirrors upstream `ensureSomeFrames`.
+    for _ in range(3):
+        await page.evaluate(
+            "() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f)))"
+        )
+    await page.screenshot()
+    await asyncio.wait_for(event.wait(), timeout=10)
+    await page.screencast.stop()
+    assert len(received) >= 1
+    assert all(isinstance(d, bytes) and len(d) > 0 for d in received)
+
+
+async def test_starting_twice_should_throw(page: Page) -> None:
+    await page.screencast.start(on_frame=lambda f: None)
+    try:
+        with pytest.raises(Exception, match="already started"):
+            await page.screencast.start(on_frame=lambda f: None)
+    finally:
+        await page.screencast.stop()
+
+
+async def test_show_overlays_and_overlay_apis_should_not_throw(page: Page) -> None:
+    await page.screencast.start(on_frame=lambda f: None)
+    try:
+        await page.screencast.show_overlay("<div>hello</div>", duration=100)
+        await page.screencast.show_chapter("ch", description="desc", duration=100)
+        await page.screencast.hide_overlays()
+        await page.screencast.show_overlays()
+        await page.screencast.show_actions(duration=100, position="top-right")
+        await page.screencast.hide_actions()
+    finally:
+        await page.screencast.stop()
diff --git a/tests/async/test_screenshot.py b/tests/async/test_screenshot.py
new file mode 100644
index 000000000..36149225f
--- /dev/null
+++ b/tests/async/test_screenshot.py
@@ -0,0 +1,79 @@
+# 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.
+
+from pathlib import Path
+from typing import Callable
+
+from PIL import Image
+
+from playwright.async_api import Page
+from tests.server import Server
+from tests.utils import must
+
+
+def assert_image_file_format(path: Path, image_format: str) -> None:
+    with Image.open(path) as img:
+        assert img.format == image_format
+
+
+async def test_should_screenshot_with_mask(
+    page: Page, server: Server, assert_to_be_golden: Callable[[bytes, str], None]
+) -> None:
+    await page.set_viewport_size(
+        {
+            "width": 500,
+            "height": 500,
+        }
+    )
+    await page.goto(server.PREFIX + "/grid.html")
+    assert_to_be_golden(
+        await page.screenshot(mask=[page.locator("div").nth(5)]),
+        "mask-should-work-with-page.png",
+    )
+    assert_to_be_golden(
+        await page.locator("body").screenshot(mask=[page.locator("div").nth(5)]),
+        "mask-should-work-with-locator.png",
+    )
+    assert_to_be_golden(
+        await must(await page.query_selector("body")).screenshot(
+            mask=[page.locator("div").nth(5)]
+        ),
+        "mask-should-work-with-element-handle.png",
+    )
+
+
+async def test_should_infer_screenshot_type_from_path(
+    page: Page, tmp_path: Path
+) -> None:
+    output_png_file = tmp_path / "foo.png"
+    await page.screenshot(path=output_png_file)
+    assert_image_file_format(output_png_file, "PNG")
+
+    output_jpeg_file = tmp_path / "bar.jpeg"
+    await page.screenshot(path=output_jpeg_file)
+    assert_image_file_format(output_jpeg_file, "JPEG")
+
+    output_jpg_file = tmp_path / "bar.jpg"
+    await page.screenshot(path=output_jpg_file)
+    assert_image_file_format(output_jpg_file, "JPEG")
+
+
+async def test_should_screenshot_with_type_argument(page: Page, tmp_path: Path) -> None:
+    output_jpeg_with_png_extension = tmp_path / "foo_jpeg.png"
+    await page.screenshot(path=output_jpeg_with_png_extension, type="jpeg")
+    assert_image_file_format(output_jpeg_with_png_extension, "JPEG")
+
+    output_png_with_jpeg_extension = tmp_path / "bar_png.jpeg"
+    await page.screenshot(path=output_png_with_jpeg_extension, type="png")
+    assert_image_file_format(output_png_with_jpeg_extension, "PNG")
diff --git a/tests/async/test_selector_generator.py b/tests/async/test_selector_generator.py
new file mode 100644
index 000000000..6668020da
--- /dev/null
+++ b/tests/async/test_selector_generator.py
@@ -0,0 +1,50 @@
+# 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 pytest
+
+from playwright.async_api import Error, Page, Playwright
+
+
+async def test_should_use_data_test_id_in_strict_errors(
+    page: Page, playwright: Playwright
+) -> None:
+    playwright.selectors.set_test_id_attribute("data-custom-id")
+    try:
+        await page.set_content(
+            """
+          <div>
+            <div></div>
+            <div>
+              <div></div>
+              <div></div>
+            </div>
+          </div>
+          <div>
+            <div class='foo bar:0' data-custom-id='One'>
+            </div>
+            <div class='foo bar:1' data-custom-id='Two'>
+            </div>
+          </div>
+        """
+        )
+        with pytest.raises(Error) as exc_info:
+            await page.locator(".foo").hover()
+        assert "strict mode violation" in exc_info.value.message
+        assert '<div class="foo bar:0' in exc_info.value.message
+        assert '<div class="foo bar:1' in exc_info.value.message
+        assert 'aka get_by_test_id("One")' in exc_info.value.message
+        assert 'aka get_by_test_id("Two")' in exc_info.value.message
+    finally:
+        playwright.selectors.set_test_id_attribute("data-testid")
diff --git a/tests/async/test_selectors_get_by.py b/tests/async/test_selectors_get_by.py
new file mode 100644
index 000000000..718264b62
--- /dev/null
+++ b/tests/async/test_selectors_get_by.py
@@ -0,0 +1,218 @@
+# 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 re
+
+from playwright.async_api import Page, expect
+
+
+async def test_get_by_escaping(page: Page) -> None:
+    await page.set_content(
+        """
+        <label id=label for=control>Hello my
+wo"rld</label><input id=control />"""
+    )
+    await page.eval_on_selector(
+        "input",
+        """input => {
+        input.setAttribute('placeholder', 'hello my\\nwo"rld');
+        input.setAttribute('title', 'hello my\\nwo"rld');
+        input.setAttribute('alt', 'hello my\\nwo"rld');
+    }""",
+    )
+    await expect(page.get_by_text('hello my\nwo"rld')).to_have_attribute("id", "label")
+    await expect(page.get_by_text('hello       my     wo"rld')).to_have_attribute(
+        "id", "label"
+    )
+    await expect(page.get_by_label('hello my\nwo"rld')).to_have_attribute(
+        "id", "control"
+    )
+    await expect(page.get_by_placeholder('hello my\nwo"rld')).to_have_attribute(
+        "id", "control"
+    )
+    await expect(page.get_by_alt_text('hello my\nwo"rld')).to_have_attribute(
+        "id", "control"
+    )
+    await expect(page.get_by_title('hello my\nwo"rld')).to_have_attribute(
+        "id", "control"
+    )
+
+    await page.set_content(
+        """
+        <label id=label for=control>Hello my
+world</label><input id=control />"""
+    )
+    await page.eval_on_selector(
+        "input",
+        """input => {
+        input.setAttribute('placeholder', 'hello my\\nworld');
+        input.setAttribute('title', 'hello my\\nworld');
+        input.setAttribute('alt', 'hello my\\nworld');
+    }""",
+    )
+    await expect(page.get_by_text("hello my\nworld")).to_have_attribute("id", "label")
+    await expect(page.get_by_text("hello        my    world")).to_have_attribute(
+        "id", "label"
+    )
+    await expect(page.get_by_label("hello my\nworld")).to_have_attribute(
+        "id", "control"
+    )
+    await expect(page.get_by_placeholder("hello my\nworld")).to_have_attribute(
+        "id", "control"
+    )
+    await expect(page.get_by_alt_text("hello my\nworld")).to_have_attribute(
+        "id", "control"
+    )
+    await expect(page.get_by_title("hello my\nworld")).to_have_attribute(
+        "id", "control"
+    )
+
+    await page.set_content("""<div id=target title="my title">Text here</div>""")
+    await expect(page.get_by_title("my title", exact=True)).to_have_count(
+        1, timeout=500
+    )
+    await expect(page.get_by_title("my t\\itle", exact=True)).to_have_count(
+        0, timeout=500
+    )
+    await expect(page.get_by_title("my t\\\\itle", exact=True)).to_have_count(
+        0, timeout=500
+    )
+
+    await page.set_content(
+        """<label for=target>foo &gt;&gt; bar</label><input id=target>"""
+    )
+    await page.eval_on_selector(
+        "input",
+        """input => {
+        input.setAttribute('placeholder', 'foo >> bar');
+        input.setAttribute('title', 'foo >> bar');
+        input.setAttribute('alt', 'foo >> bar');
+    }""",
+    )
+    assert await page.get_by_text("foo >> bar").text_content() == "foo >> bar"
+    await expect(page.locator("label")).to_have_text("foo >> bar")
+    await expect(page.get_by_text("foo >> bar")).to_have_text("foo >> bar")
+    assert (
+        await page.get_by_text(re.compile("foo >> bar")).text_content() == "foo >> bar"
+    )
+    await expect(page.get_by_label("foo >> bar")).to_have_attribute("id", "target")
+    await expect(page.get_by_label(re.compile("foo >> bar"))).to_have_attribute(
+        "id", "target"
+    )
+    await expect(page.get_by_placeholder("foo >> bar")).to_have_attribute(
+        "id", "target"
+    )
+    await expect(page.get_by_alt_text("foo >> bar")).to_have_attribute("id", "target")
+    await expect(page.get_by_title("foo >> bar")).to_have_attribute("id", "target")
+    await expect(page.get_by_placeholder(re.compile("foo >> bar"))).to_have_attribute(
+        "id", "target"
+    )
+    await expect(page.get_by_alt_text(re.compile("foo >> bar"))).to_have_attribute(
+        "id", "target"
+    )
+    await expect(page.get_by_title(re.compile("foo >> bar"))).to_have_attribute(
+        "id", "target"
+    )
+
+
+async def test_get_by_role_escaping(
+    page: Page,
+) -> None:
+    await page.set_content(
+        """
+        <a href="https://playwright.dev">issues 123</a>
+        <a href="https://playwright.dev">he llo 56</a>
+        <button>Click me</button>
+    """
+    )
+    assert await page.get_by_role("button").evaluate_all(
+        "els => els.map(e => e.outerHTML)"
+    ) == [
+        "<button>Click me</button>",
+    ]
+    assert await page.get_by_role("link").evaluate_all(
+        "els => els.map(e => e.outerHTML)"
+    ) == [
+        """<a href="https://playwright.dev">issues 123</a>""",
+        """<a href="https://playwright.dev">he llo 56</a>""",
+    ]
+
+    assert await page.get_by_role("link", name="issues 123").evaluate_all(
+        "els => els.map(e => e.outerHTML)"
+    ) == [
+        """<a href="https://playwright.dev">issues 123</a>""",
+    ]
+    assert await page.get_by_role("link", name="sues").evaluate_all(
+        "els => els.map(e => e.outerHTML)"
+    ) == [
+        """<a href="https://playwright.dev">issues 123</a>""",
+    ]
+    assert await page.get_by_role("link", name="  he    \n  llo ").evaluate_all(
+        "els => els.map(e => e.outerHTML)"
+    ) == [
+        """<a href="https://playwright.dev">he llo 56</a>""",
+    ]
+    assert (
+        await page.get_by_role("button", name="issues").evaluate_all(
+            "els => els.map(e => e.outerHTML)"
+        )
+        == []
+    )
+
+    assert (
+        await page.get_by_role("link", name="sues", exact=True).evaluate_all(
+            "els => els.map(e => e.outerHTML)"
+        )
+        == []
+    )
+    assert await page.get_by_role(
+        "link", name="   he \n llo 56 ", exact=True
+    ).evaluate_all("els => els.map(e => e.outerHTML)") == [
+        """<a href="https://playwright.dev">he llo 56</a>""",
+    ]
+
+    assert await page.get_by_role("button", name="Click me", exact=True).evaluate_all(
+        "els => els.map(e => e.outerHTML)"
+    ) == [
+        "<button>Click me</button>",
+    ]
+    assert (
+        await page.get_by_role("button", name="Click \\me", exact=True).evaluate_all(
+            "els => els.map(e => e.outerHTML)"
+        )
+        == []
+    )
+    assert (
+        await page.get_by_role("button", name="Click \\\\me", exact=True).evaluate_all(
+            "els => els.map(e => e.outerHTML)"
+        )
+        == []
+    )
+
+
+async def test_include_hidden_should_work(
+    page: Page,
+) -> None:
+    await page.set_content("""<button style="display: none">Hidden</button>""")
+    assert (
+        await page.get_by_role("button", name="Hidden").evaluate_all(
+            "els => els.map(e => e.outerHTML)"
+        )
+        == []
+    )
+    assert await page.get_by_role(
+        "button", name="Hidden", include_hidden=True
+    ).evaluate_all("els => els.map(e => e.outerHTML)") == [
+        """<button style="display: none">Hidden</button>""",
+    ]
diff --git a/tests/async/test_selectors_misc.py b/tests/async/test_selectors_misc.py
new file mode 100644
index 000000000..5ad6c3519
--- /dev/null
+++ b/tests/async/test_selectors_misc.py
@@ -0,0 +1,82 @@
+# 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 pytest
+
+from playwright._impl._browser import Browser
+from playwright._impl._errors import Error
+from playwright._impl._selectors import Selectors
+from playwright.async_api import Page
+
+
+async def test_should_work_with_internal_and(page: Page) -> None:
+    await page.set_content(
+        """
+        <div class=foo>hello</div><div class=bar>world</div>
+        <span class=foo>hello2</span><span class=bar>world2</span>
+    """
+    )
+    assert (
+        await page.eval_on_selector_all(
+            'div >> internal:and="span"', "els => els.map(e => e.textContent)"
+        )
+    ) == []
+    assert (
+        await page.eval_on_selector_all(
+            'div >> internal:and=".foo"', "els => els.map(e => e.textContent)"
+        )
+    ) == ["hello"]
+    assert (
+        await page.eval_on_selector_all(
+            'div >> internal:and=".bar"', "els => els.map(e => e.textContent)"
+        )
+    ) == ["world"]
+    assert (
+        await page.eval_on_selector_all(
+            'span >> internal:and="span"', "els => els.map(e => e.textContent)"
+        )
+    ) == ["hello2", "world2"]
+    assert (
+        await page.eval_on_selector_all(
+            '.foo >> internal:and="div"', "els => els.map(e => e.textContent)"
+        )
+    ) == ["hello"]
+    assert (
+        await page.eval_on_selector_all(
+            '.bar >> internal:and="span"', "els => els.map(e => e.textContent)"
+        )
+    ) == ["world2"]
+
+
+async def test_should_throw_already_registered_error_when_registering(
+    selectors: Selectors,
+    browser: Browser,
+) -> None:
+    create_tag_selector = """
+    () => ({
+        query(root, selector) {
+            return root.querySelector(selector);
+        },
+        queryAll(root, selector) {
+            return Array.from(root.querySelectorAll(selector));
+        }
+    })
+    """
+    name = f"alreadyRegistered-{browser.browser_type.name}"
+    await selectors.register(name, create_tag_selector)
+    with pytest.raises(
+        Error,
+        match=f'Selectors.register: "{name}" selector engine has been already registered',
+    ):
+        await selectors.register(name, create_tag_selector)
diff --git a/tests/async/test_selectors_text.py b/tests/async/test_selectors_text.py
new file mode 100644
index 000000000..2135dcade
--- /dev/null
+++ b/tests/async/test_selectors_text.py
@@ -0,0 +1,283 @@
+# 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 re
+
+import pytest
+
+from playwright.async_api import Error, Page, expect
+
+
+async def test_has_text_and_internal_text_should_match_full_node_text_in_strict_mode(
+    page: Page,
+) -> None:
+    await page.set_content(
+        """
+        <div id=div1>hello<span>world</span></div>
+        <div id=div2>hello</div>
+    """
+    )
+    await expect(page.get_by_text("helloworld", exact=True)).to_have_id("div1")
+    await expect(page.get_by_text("hello", exact=True)).to_have_id("div2")
+    await expect(page.locator("div", has_text=re.compile("^helloworld$"))).to_have_id(
+        "div1"
+    )
+    await expect(page.locator("div", has_text=re.compile("^hello$"))).to_have_id("div2")
+
+    await page.set_content(
+        """
+        <div id=div1><span id=span1>hello</span>world</div>
+        <div id=div2><span id=span2>hello</span></div>
+    """
+    )
+    await expect(page.get_by_text("helloworld", exact=True)).to_have_id("div1")
+    assert await page.get_by_text("hello", exact=True).evaluate_all(
+        "els => els.map(e => e.id)"
+    ) == ["span1", "span2"]
+    await expect(page.locator("div", has_text=re.compile("^helloworld$"))).to_have_id(
+        "div1"
+    )
+    await expect(page.locator("div", has_text=re.compile("^hello$"))).to_have_id("div2")
+
+
+async def test_should_work(page: Page) -> None:
+    await page.set_content(
+        """
+        <div>yo</div><div>ya</div><div>\nye  </div>
+    """
+    )
+    assert await page.eval_on_selector("text=ya", "e => e.outerHTML") == "<div>ya</div>"
+    assert (
+        await page.eval_on_selector('text="ya"', "e => e.outerHTML") == "<div>ya</div>"
+    )
+    assert (
+        await page.eval_on_selector("text=/^[ay]+$/", "e => e.outerHTML")
+        == "<div>ya</div>"
+    )
+    assert (
+        await page.eval_on_selector("text=/Ya/i", "e => e.outerHTML") == "<div>ya</div>"
+    )
+    assert (
+        await page.eval_on_selector("text=ye", "e => e.outerHTML")
+        == "<div>\nye  </div>"
+    )
+    assert ">\nye  </div>" in await page.get_by_text("ye").evaluate("e => e.outerHTML")
+
+    await page.set_content(
+        """
+        <div> ye </div><div>ye</div>
+    """
+    )
+    assert (
+        await page.eval_on_selector('text="ye"', "e => e.outerHTML")
+        == "<div> ye </div>"
+    )
+    assert "> ye </div>" in await page.get_by_text("ye", exact=True).first.evaluate(
+        "e => e.outerHTML"
+    )
+
+    await page.set_content(
+        """
+        <div>yo</div><div>"ya</div><div> hello world! </div>
+    """
+    )
+    assert (
+        await page.eval_on_selector('text="\\"ya"', "e => e.outerHTML")
+        == '<div>"ya</div>'
+    )
+    assert (
+        await page.eval_on_selector("text=/hello/", "e => e.outerHTML")
+        == "<div> hello world! </div>"
+    )
+    assert (
+        await page.eval_on_selector("text=/^\\s*heLLo/i", "e => e.outerHTML")
+        == "<div> hello world! </div>"
+    )
+
+    await page.set_content(
+        """
+        <div>yo<div>ya</div>hey<div>hey</div></div>
+    """
+    )
+    assert (
+        await page.eval_on_selector("text=hey", "e => e.outerHTML") == "<div>hey</div>"
+    )
+    assert (
+        await page.eval_on_selector('text=yo>>text="ya"', "e => e.outerHTML")
+        == "<div>ya</div>"
+    )
+    assert (
+        await page.eval_on_selector('text=yo>> text="ya"', "e => e.outerHTML")
+        == "<div>ya</div>"
+    )
+    assert (
+        await page.eval_on_selector("text=yo >>text='ya'", "e => e.outerHTML")
+        == "<div>ya</div>"
+    )
+    assert (
+        await page.eval_on_selector("text=yo >> text='ya'", "e => e.outerHTML")
+        == "<div>ya</div>"
+    )
+    assert (
+        await page.eval_on_selector("'yo'>>\"ya\"", "e => e.outerHTML")
+        == "<div>ya</div>"
+    )
+    assert (
+        await page.eval_on_selector("\"yo\" >> 'ya'", "e => e.outerHTML")
+        == "<div>ya</div>"
+    )
+
+    await page.set_content(
+        """
+        <div>yo<span id="s1"></span></div><div>yo<span id="s2"></span><span id="s3"></span></div>
+        """
+    )
+    assert (
+        await page.eval_on_selector_all(
+            "text=yo", "es => es.map(e => e.outerHTML).join('\\n')"
+        )
+        == '<div>yo<span id="s1"></span></div>\n<div>yo<span id="s2"></span><span id="s3"></span></div>'
+    )
+
+    await page.set_content("<div>'</div><div>\"</div><div>\\</div><div>x</div>")
+    assert (
+        await page.eval_on_selector("text='\\''", "e => e.outerHTML") == "<div>'</div>"
+    )
+    assert (
+        await page.eval_on_selector("text='\"'", "e => e.outerHTML") == '<div>"</div>'
+    )
+    assert (
+        await page.eval_on_selector('text="\\""', "e => e.outerHTML") == '<div>"</div>'
+    )
+    assert (
+        await page.eval_on_selector('text="\'"', "e => e.outerHTML") == "<div>'</div>"
+    )
+    assert (
+        await page.eval_on_selector('text="\\x"', "e => e.outerHTML") == "<div>x</div>"
+    )
+    assert (
+        await page.eval_on_selector("text='\\x'", "e => e.outerHTML") == "<div>x</div>"
+    )
+    assert (
+        await page.eval_on_selector("text='\\\\'", "e => e.outerHTML")
+        == "<div>\\</div>"
+    )
+    assert (
+        await page.eval_on_selector('text="\\\\"', "e => e.outerHTML")
+        == "<div>\\</div>"
+    )
+    assert await page.eval_on_selector('text="', "e => e.outerHTML") == '<div>"</div>'
+    assert await page.eval_on_selector("text='", "e => e.outerHTML") == "<div>'</div>"
+    assert await page.eval_on_selector('"x"', "e => e.outerHTML") == "<div>x</div>"
+    assert await page.eval_on_selector("'x'", "e => e.outerHTML") == "<div>x</div>"
+    with pytest.raises(Error):
+        await page.query_selector_all('"')
+    with pytest.raises(Error):
+        await page.query_selector_all("'")
+
+    await page.set_content("<div> ' </div><div> \" </div>")
+    assert await page.eval_on_selector('text="', "e => e.outerHTML") == '<div> " </div>'
+    assert await page.eval_on_selector("text='", "e => e.outerHTML") == "<div> ' </div>"
+
+    await page.set_content("<div>Hi''&gt;&gt;foo=bar</div>")
+    assert (
+        await page.eval_on_selector("text=\"Hi''>>foo=bar\"", "e => e.outerHTML")
+        == "<div>Hi''&gt;&gt;foo=bar</div>"
+    )
+    await page.set_content("<div>Hi'\"&gt;&gt;foo=bar</div>")
+    assert (
+        await page.eval_on_selector('text="Hi\'\\">>foo=bar"', "e => e.outerHTML")
+        == "<div>Hi'\"&gt;&gt;foo=bar</div>"
+    )
+
+    await page.set_content("<div>Hi&gt;&gt;<span></span></div>")
+    assert (
+        await page.eval_on_selector('text="Hi>>">>span', "e => e.outerHTML")
+        == "<span></span>"
+    )
+    assert (
+        await page.eval_on_selector("text=/Hi\\>\\>/ >> span", "e => e.outerHTML")
+        == "<span></span>"
+    )
+
+    await page.set_content("<div>a<br>b</div><div>a</div>")
+    assert (
+        await page.eval_on_selector("text=a", "e => e.outerHTML") == "<div>a<br>b</div>"
+    )
+    assert (
+        await page.eval_on_selector("text=b", "e => e.outerHTML") == "<div>a<br>b</div>"
+    )
+    assert (
+        await page.eval_on_selector("text=ab", "e => e.outerHTML")
+        == "<div>a<br>b</div>"
+    )
+    assert await page.query_selector("text=abc") is None
+    assert await page.eval_on_selector_all("text=a", "els => els.length") == 2
+    assert await page.eval_on_selector_all("text=b", "els => els.length") == 1
+    assert await page.eval_on_selector_all("text=ab", "els => els.length") == 1
+    assert await page.eval_on_selector_all("text=abc", "els => els.length") == 0
+
+    await page.set_content("<div></div><span></span>")
+    await page.eval_on_selector(
+        "div",
+        """div => {
+        div.appendChild(document.createTextNode('hello'))
+        div.appendChild(document.createTextNode('world'))
+    }""",
+    )
+    await page.eval_on_selector(
+        "span",
+        """span => {
+        span.appendChild(document.createTextNode('hello'))
+        span.appendChild(document.createTextNode('world'))
+    }""",
+    )
+    assert (
+        await page.eval_on_selector("text=lowo", "e => e.outerHTML")
+        == "<div>helloworld</div>"
+    )
+    assert (
+        await page.eval_on_selector_all(
+            "text=lowo", "els => els.map(e => e.outerHTML).join('')"
+        )
+        == "<div>helloworld</div><span>helloworld</span>"
+    )
+
+    await page.set_content("<span>Sign&nbsp;in</span><span>Hello\n \nworld</span>")
+    assert (
+        await page.eval_on_selector("text=Sign in", "e => e.outerHTML")
+        == "<span>Sign&nbsp;in</span>"
+    )
+    assert len((await page.query_selector_all("text=Sign \tin"))) == 1
+    assert len((await page.query_selector_all('text="Sign in"'))) == 1
+    assert (
+        await page.eval_on_selector("text=lo wo", "e => e.outerHTML")
+        == "<span>Hello\n \nworld</span>"
+    )
+    assert (
+        await page.eval_on_selector('text="Hello world"', "e => e.outerHTML")
+        == "<span>Hello\n \nworld</span>"
+    )
+    assert await page.query_selector('text="lo wo"') is None
+    assert len((await page.query_selector_all("text=lo \nwo"))) == 1
+    assert len(await page.query_selector_all('text="lo \nwo"')) == 0
+
+    await page.set_content("<div>let's<span>hello</span></div>")
+    assert (
+        await page.eval_on_selector("text=/let's/i >> span", "e => e.outerHTML")
+        == "<span>hello</span>"
+    )
+    assert (
+        await page.eval_on_selector("text=/let\\'s/i >> span", "e => e.outerHTML")
+        == "<span>hello</span>"
+    )
diff --git a/tests/async/test_tap.py b/tests/async/test_tap.py
index f60cfddce..abb3c61e5 100644
--- a/tests/async/test_tap.py
+++ b/tests/async/test_tap.py
@@ -13,20 +13,21 @@
 # limitations under the License.
 
 import asyncio
+from typing import AsyncGenerator, Optional, cast
 
 import pytest
 
-from playwright.async_api import ElementHandle, JSHandle
+from playwright.async_api import Browser, BrowserContext, ElementHandle, JSHandle, Page
 
 
 @pytest.fixture
-async def context(browser):
+async def context(browser: Browser) -> AsyncGenerator[BrowserContext, None]:
     context = await browser.new_context(has_touch=True)
     yield context
     await context.close()
 
 
-async def test_should_send_all_of_the_correct_events(page):
+async def test_should_send_all_of_the_correct_events(page: Page) -> None:
     await page.set_content(
         """
             <div id="a" style="background: lightblue; width: 50px; height: 50px">a</div>
@@ -54,7 +55,7 @@ async def test_should_send_all_of_the_correct_events(page):
     ]
 
 
-async def test_should_not_send_mouse_events_touchstart_is_canceled(page):
+async def test_should_not_send_mouse_events_touchstart_is_canceled(page: Page) -> None:
     await page.set_content("hello world")
     await page.evaluate(
         """() => {
@@ -76,7 +77,7 @@ async def test_should_not_send_mouse_events_touchstart_is_canceled(page):
     ]
 
 
-async def test_should_not_send_mouse_events_touchend_is_canceled(page):
+async def test_should_not_send_mouse_events_touchend_is_canceled(page: Page) -> None:
     await page.set_content("hello world")
     await page.evaluate(
         """() => {
@@ -98,7 +99,7 @@ async def test_should_not_send_mouse_events_touchend_is_canceled(page):
     ]
 
 
-async def test_should_work_with_modifiers(page):
+async def test_should_work_with_modifiers(page: Page) -> None:
     await page.set_content("hello world")
     alt_key_promise = asyncio.create_task(
         page.evaluate(
@@ -115,7 +116,7 @@ async def test_should_work_with_modifiers(page):
     assert await alt_key_promise is True
 
 
-async def test_should_send_well_formed_touch_points(page):
+async def test_should_send_well_formed_touch_points(page: Page) -> None:
     promises = asyncio.gather(
         page.evaluate(
             """() => new Promise(resolve => {
@@ -172,15 +173,18 @@ async def test_should_send_well_formed_touch_points(page):
     assert touchend == []
 
 
-async def test_should_wait_until_an_element_is_visible_to_tap_it(page):
-    div = await page.evaluate_handle(
-        """() => {
+async def test_should_wait_until_an_element_is_visible_to_tap_it(page: Page) -> None:
+    div = cast(
+        ElementHandle,
+        await page.evaluate_handle(
+            """() => {
             const button = document.createElement('button');
             button.textContent = 'not clicked';
             document.body.appendChild(button);
             button.style.display = 'none';
             return button;
         }"""
+        ),
     )
     tap_promise = asyncio.create_task(div.tap())
     await asyncio.sleep(0)  # issue tap
@@ -190,7 +194,36 @@ async def test_should_wait_until_an_element_is_visible_to_tap_it(page):
     assert await div.text_content() == "clicked"
 
 
-async def track_events(target: ElementHandle) -> JSHandle:
+async def test_locators_tap(page: Page) -> None:
+    await page.set_content(
+        """
+        <div id="a" style="background: lightblue; width: 50px; height: 50px">a</div>
+        <div id="b" style="background: pink; width: 50px; height: 50px">b</div>
+    """
+    )
+    await page.locator("#a").tap()
+    element_handle = await track_events(await page.query_selector("#b"))
+    await page.locator("#b").tap()
+    assert await element_handle.json_value() == [
+        "pointerover",
+        "pointerenter",
+        "pointerdown",
+        "touchstart",
+        "pointerup",
+        "pointerout",
+        "pointerleave",
+        "touchend",
+        "mouseover",
+        "mouseenter",
+        "mousemove",
+        "mousedown",
+        "mouseup",
+        "click",
+    ]
+
+
+async def track_events(target: Optional[ElementHandle]) -> JSHandle:
+    assert target
     return await target.evaluate_handle(
         """target => {
             const events = [];
diff --git a/tests/async/test_tracing.py b/tests/async/test_tracing.py
new file mode 100644
index 000000000..076329c5e
--- /dev/null
+++ b/tests/async/test_tracing.py
@@ -0,0 +1,445 @@
+# 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 asyncio
+import json
+import re
+import zipfile
+from pathlib import Path
+from typing import AsyncContextManager, Callable
+
+from playwright.async_api import (
+    Browser,
+    BrowserContext,
+    BrowserType,
+    Page,
+    Playwright,
+    Response,
+    expect,
+)
+from tests.server import Server
+
+from .conftest import TraceViewerPage
+
+
+async def test_browser_context_output_trace(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    context = await browser.new_context()
+    await context.tracing.start(screenshots=True, snapshots=True)
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/grid.html")
+    await context.tracing.stop(path=tmp_path / "trace.zip")
+    assert Path(tmp_path / "trace.zip").exists()
+
+
+async def test_start_stop(browser: Browser) -> None:
+    context = await browser.new_context()
+    await context.tracing.start()
+    await context.tracing.stop()
+    await context.close()
+
+
+async def test_browser_context_should_not_throw_when_stopping_without_start_but_not_exporting(
+    context: BrowserContext,
+) -> None:
+    await context.tracing.stop()
+
+
+async def test_browser_context_output_trace_chunk(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    context = await browser.new_context()
+    await context.tracing.start(screenshots=True, snapshots=True)
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/grid.html")
+    button = page.locator(".box").first
+
+    await context.tracing.start_chunk(title="foo")
+    await button.click()
+    await context.tracing.stop_chunk(path=tmp_path / "trace1.zip")
+    assert Path(tmp_path / "trace1.zip").exists()
+
+    await context.tracing.start_chunk(title="foo")
+    await button.click()
+    await context.tracing.stop_chunk(path=tmp_path / "trace2.zip")
+    assert Path(tmp_path / "trace2.zip").exists()
+
+
+async def test_should_collect_sources(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
+) -> None:
+    await context.tracing.start(sources=True)
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<button>Click</button>")
+
+    async def my_method_outer() -> None:
+        async def my_method_inner() -> None:
+            await page.get_by_text("Click").click()
+
+        await my_method_inner()
+
+    await my_method_outer()
+    path = tmp_path / "trace.zip"
+    await context.tracing.stop(path=path)
+
+    async with show_trace_viewer(path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+            ]
+        )
+        await trace_viewer.show_source_tab()
+        # Check that stack frames are shown (they might be anonymous in Python)
+        await expect(trace_viewer.stack_frames).to_contain_text(
+            [
+                re.compile(r"my_method_inner"),
+                re.compile(r"my_method_outer"),
+                re.compile(r"test_should_collect_sources"),
+            ]
+        )
+
+        await trace_viewer.select_action("Set content")
+        # Check that the source file is shown
+        await expect(
+            trace_viewer.page.locator(".source-tab-file-name")
+        ).to_have_attribute("title", re.compile(r".*test_.*\.py"))
+        await expect(trace_viewer.page.locator(".source-line-running")).to_contain_text(
+            'page.set_content("<button>Click</button>")'
+        )
+
+
+async def test_should_collect_trace_with_resources_but_no_js(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
+) -> None:
+    await context.tracing.start(screenshots=True, snapshots=True)
+    await page.goto(server.PREFIX + "/frames/frame.html")
+    await page.set_content("<button>Click</button>")
+    await page.click('"Click"')
+    await page.mouse.move(20, 20)
+    await page.mouse.dblclick(30, 30)
+    await page.request.get(server.EMPTY_PAGE)
+    await page.keyboard.insert_text("abc")
+    await page.wait_for_timeout(2000)  # Give it some time to produce screenshots.
+    await page.route("**/empty.html", lambda route: route.continue_())
+    await page.goto(server.EMPTY_PAGE)
+    await page.goto(server.PREFIX + "/one-style.html")
+    await page.close()
+    trace_file_path = tmp_path / "trace.zip"
+    await context.tracing.stop(path=trace_file_path)
+
+    async with show_trace_viewer(trace_file_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/frames/frame\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+                re.compile(r"Mouse move"),
+                re.compile(r"Double click"),
+                re.compile(r"GET \"/empty\.html\""),
+                re.compile(r'Insert "abc"'),
+                re.compile(r"Wait for timeout"),
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r'Navigate to "/one-style\.html"'),
+                re.compile(r"Close"),
+            ]
+        )
+
+        await trace_viewer.select_action("Set content")
+        await expect(
+            trace_viewer.page.locator(".browser-frame-address-bar")
+        ).to_have_text(server.PREFIX + "/frames/frame.html")
+        frame = await trace_viewer.snapshot_frame("Set content", 0, False)
+        await expect(frame.locator("button")).to_have_text("Click")
+
+
+async def test_should_correctly_determine_sync_apiname(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable,
+) -> None:
+    await context.tracing.start(screenshots=True, snapshots=True)
+
+    received_response: "asyncio.Future[None]" = asyncio.Future()
+
+    async def _handle_response(response: Response) -> None:
+        await response.request.all_headers()
+        await response.text()
+        received_response.set_result(None)
+
+    page.once("response", _handle_response)
+    await page.goto(server.PREFIX + "/grid.html")
+    await received_response
+    await page.close()
+    trace_file_path = tmp_path / "trace.zip"
+    await context.tracing.stop(path=trace_file_path)
+
+    async with show_trace_viewer(trace_file_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/grid\.html"'),
+                re.compile(r"Close"),
+            ]
+        )
+
+
+async def test_should_collect_two_traces(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
+) -> None:
+    await context.tracing.start(screenshots=True, snapshots=True)
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<button>Click</button>")
+    await page.click('"Click"')
+    tracing1_path = tmp_path / "trace1.zip"
+    await context.tracing.stop(path=tracing1_path)
+
+    await context.tracing.start(screenshots=True, snapshots=True)
+    await page.dblclick('"Click"')
+    await page.close()
+    tracing2_path = tmp_path / "trace2.zip"
+    await context.tracing.stop(path=tracing2_path)
+
+    async with show_trace_viewer(tracing1_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+            ]
+        )
+
+    async with show_trace_viewer(tracing2_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r"Double click"),
+                re.compile(r"Close"),
+            ]
+        )
+
+
+async def test_should_work_with_playwright_context_managers(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
+) -> None:
+    await context.tracing.start(screenshots=True, snapshots=True)
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content("<button>Click</button>")
+    async with page.expect_console_message() as message_info:
+        await page.evaluate('() => console.log("hello")')
+        await page.click('"Click"')
+    assert (await message_info.value).text == "hello"
+
+    async with page.expect_popup():
+        await page.evaluate("window._popup = window.open(document.location.href)")
+    trace_file_path = tmp_path / "trace.zip"
+    await context.tracing.stop(path=trace_file_path)
+
+    async with show_trace_viewer(trace_file_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r'Wait for event "page\.expect_event\(console\)"'),
+                re.compile(r"Evaluate"),
+                re.compile(r"Click"),
+                re.compile(r'Wait for event "page\.expect_event\(popup\)"'),
+                re.compile(r"Evaluate"),
+            ]
+        )
+
+
+async def test_should_display_wait_for_load_state_even_if_did_not_wait_for_it(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
+) -> None:
+    await context.tracing.start(screenshots=True, snapshots=True)
+
+    await page.goto(server.EMPTY_PAGE)
+    await page.wait_for_load_state("load")
+    await page.wait_for_load_state("load")
+
+    trace_file_path = tmp_path / "trace.zip"
+    await context.tracing.stop(path=trace_file_path)
+
+    async with show_trace_viewer(trace_file_path) as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r'Wait for event "frame\.wait_for_load_state"'),
+                re.compile(r'Wait for event "frame\.wait_for_load_state"'),
+            ]
+        )
+
+
+async def test_should_respect_traces_dir_and_name(
+    browser_type: BrowserType,
+    server: Server,
+    tmp_path: Path,
+    launch_arguments: dict,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
+) -> None:
+    traces_dir = tmp_path / "traces"
+    browser = await browser_type.launch(traces_dir=traces_dir, **launch_arguments)
+    context = await browser.new_context()
+    page = await context.new_page()
+
+    await context.tracing.start(name="name1", snapshots=True)
+    await page.goto(server.PREFIX + "/one-style.html")
+    await context.tracing.stop_chunk(path=tmp_path / "trace1.zip")
+    assert (traces_dir / "name1.trace").exists()
+    assert (traces_dir / "name1.network").exists()
+
+    await context.tracing.start_chunk(name="name2")
+    await page.goto(server.PREFIX + "/har.html")
+    await context.tracing.stop(path=tmp_path / "trace2.zip")
+    assert (traces_dir / "name2.trace").exists()
+    assert (traces_dir / "name2.network").exists()
+
+    await browser.close()
+
+    async with show_trace_viewer(tmp_path / "trace1.zip") as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile('Navigate to "/one-style\\.html"'),
+            ]
+        )
+        frame = await trace_viewer.snapshot_frame(
+            'Navigate to "/one-style.html"', 0, False
+        )
+        await expect(frame.locator("body")).to_have_css(
+            "background-color", "rgb(255, 192, 203)"
+        )
+        await expect(frame.locator("body")).to_have_text("hello, world!")
+
+    async with show_trace_viewer(tmp_path / "trace2.zip") as trace_viewer:
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/har\.html"'),
+            ]
+        )
+        frame = await trace_viewer.snapshot_frame('Navigate to "/har.html"', 0, False)
+        await expect(frame.locator("body")).to_have_css(
+            "background-color", "rgb(255, 192, 203)"
+        )
+        await expect(frame.locator("body")).to_have_text("hello, world!")
+
+
+async def test_should_show_tracing_group_in_action_list(
+    context: BrowserContext,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], AsyncContextManager[TraceViewerPage]],
+) -> None:
+    await context.tracing.start()
+    page = await context.new_page()
+
+    await context.tracing.group("outer group")
+    await page.goto("data:text/html,<!DOCTYPE html><body><div>Hello world</div></body>")
+    await context.tracing.group("inner group 1")
+    await page.locator("body").click()
+    await context.tracing.group_end()
+    await context.tracing.group("inner group 2")
+    await page.get_by_text("Hello").is_visible()
+    await context.tracing.group_end()
+    await context.tracing.group_end()
+
+    trace_path = tmp_path / "trace.zip"
+    await context.tracing.stop(path=trace_path)
+
+    async with show_trace_viewer(trace_path) as trace_viewer:
+        await trace_viewer.expand_action("inner group 1")
+        await expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r"Create page"),
+                re.compile(r"outer group"),
+                re.compile(r"Navigate to \"data:\""),
+                re.compile(r"inner group 1"),
+                re.compile(r"Click"),
+                re.compile(r"inner group 2"),
+            ]
+        )
+
+
+async def test_should_start_and_stop_har(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    context = await browser.new_context()
+    page = await context.new_page()
+    har_path = tmp_path / "test.har"
+    await context.tracing.start_har(path=har_path, content="embed", mode="full")
+    await page.goto(server.PREFIX + "/empty.html")
+    await context.tracing.stop_har()
+    await context.close()
+    assert har_path.exists()
+    assert har_path.stat().st_size > 0
+
+
+async def test_should_record_a_har_with_options(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    # Ported from upstream tests/library/har.spec.ts.
+    context = await browser.new_context()
+    har_path = tmp_path / "tracing.har"
+    await context.tracing.start_har(
+        path=har_path, mode="minimal", url_filter="**/one-style.css"
+    )
+    page = await context.new_page()
+    await page.goto(server.PREFIX + "/one-style.html")
+    await context.tracing.stop_har()
+    await context.close()
+
+    log = json.loads(har_path.read_text())["log"]
+    urls = [e["request"]["url"] for e in log["entries"]]
+    assert urls == [server.PREFIX + "/one-style.css"]
+    # Minimal mode drops body sizes.
+    assert log["entries"][0]["request"]["bodySize"] == -1
+
+
+async def test_should_record_a_zipped_har_for_apirequestcontext(
+    playwright: Playwright, server: Server, tmp_path: Path
+) -> None:
+    # Ported from upstream tests/library/har.spec.ts.
+    request = await playwright.request.new_context()
+    har_path = tmp_path / "tracing.har.zip"
+    await request.tracing.start_har(path=har_path, content="attach")
+    await request.get(server.PREFIX + "/simple.json")
+    await request.tracing.stop_har()
+    await request.dispose()
+
+    with zipfile.ZipFile(har_path) as zf:
+        log = json.loads(zf.read("har.har"))["log"]
+    assert any(
+        e["request"]["url"] == server.PREFIX + "/simple.json" for e in log["entries"]
+    )
diff --git a/tests/async/test_unroute_behavior.py b/tests/async/test_unroute_behavior.py
new file mode 100644
index 000000000..ff737eaab
--- /dev/null
+++ b/tests/async/test_unroute_behavior.py
@@ -0,0 +1,509 @@
+# 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 asyncio
+import re
+
+from playwright.async_api import BrowserContext, Error, Page, Route
+from tests.server import Server
+from tests.utils import must
+
+
+async def test_context_unroute_should_not_wait_for_pending_handlers_to_complete(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    second_handler_called = False
+
+    async def _handler1(route: Route) -> None:
+        nonlocal second_handler_called
+        second_handler_called = True
+        await route.continue_()
+
+    await context.route(
+        re.compile(".*"),
+        _handler1,
+    )
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+    route_barrier_future: "asyncio.Future[None]" = asyncio.Future()
+
+    async def _handler2(route: Route) -> None:
+        route_future.set_result(route)
+        await route_barrier_future
+        await route.fallback()
+
+    await context.route(
+        re.compile(".*"),
+        _handler2,
+    )
+    navigation_task = asyncio.create_task(page.goto(server.EMPTY_PAGE))
+    await route_future
+    await context.unroute(
+        re.compile(".*"),
+        _handler2,
+    )
+    route_barrier_future.set_result(None)
+    await navigation_task
+    assert second_handler_called
+
+
+async def test_context_unroute_all_removes_all_handlers(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await context.route(
+        "**/*",
+        lambda route: route.abort(),
+    )
+    await context.route(
+        "**/empty.html",
+        lambda route: route.abort(),
+    )
+    await context.unroute_all()
+    await page.goto(server.EMPTY_PAGE)
+
+
+async def test_context_unroute_all_should_not_wait_for_pending_handlers_to_complete(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    second_handler_called = False
+
+    async def _handler1(route: Route) -> None:
+        nonlocal second_handler_called
+        second_handler_called = True
+        await route.abort()
+
+    await context.route(
+        re.compile(".*"),
+        _handler1,
+    )
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+    route_barrier_future: "asyncio.Future[None]" = asyncio.Future()
+
+    async def _handler2(route: Route) -> None:
+        route_future.set_result(route)
+        await route_barrier_future
+        await route.fallback()
+
+    await context.route(
+        re.compile(".*"),
+        _handler2,
+    )
+    navigation_task = asyncio.create_task(page.goto(server.EMPTY_PAGE))
+    await route_future
+    did_unroute = False
+
+    async def _unroute_promise() -> None:
+        nonlocal did_unroute
+        await context.unroute_all(behavior="wait")
+        did_unroute = True
+
+    unroute_task = asyncio.create_task(_unroute_promise())
+    await asyncio.sleep(0.5)
+    assert did_unroute is False
+    route_barrier_future.set_result(None)
+    await unroute_task
+    assert did_unroute
+    await navigation_task
+    assert second_handler_called is False
+
+
+async def test_context_unroute_all_should_not_wait_for_pending_handlers_to_complete_if_behavior_is_ignore_errors(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    second_handler_called = False
+
+    async def _handler1(route: Route) -> None:
+        nonlocal second_handler_called
+        second_handler_called = True
+        await route.abort()
+
+    await context.route(
+        re.compile(".*"),
+        _handler1,
+    )
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+    route_barrier_future: "asyncio.Future[None]" = asyncio.Future()
+
+    async def _handler2(route: Route) -> None:
+        route_future.set_result(route)
+        await route_barrier_future
+        raise Exception("Handler error")
+
+    await context.route(
+        re.compile(".*"),
+        _handler2,
+    )
+    navigation_task = asyncio.create_task(page.goto(server.EMPTY_PAGE))
+    await route_future
+    did_unroute = False
+
+    async def _unroute_promise() -> None:
+        await context.unroute_all(behavior="ignoreErrors")
+        nonlocal did_unroute
+        did_unroute = True
+
+    unroute_task = asyncio.create_task(_unroute_promise())
+    await asyncio.sleep(0.5)
+    await unroute_task
+    assert did_unroute
+    route_barrier_future.set_result(None)
+    try:
+        await navigation_task
+    except Error:
+        pass
+    # The error in the unrouted handler should be silently caught and remaining handler called.
+    assert not second_handler_called
+
+
+async def test_page_close_should_not_wait_for_active_route_handlers_on_the_owning_context(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+    await context.route(
+        re.compile(".*"),
+        lambda route: route_future.set_result(route),
+    )
+    await page.route(
+        re.compile(".*"),
+        lambda route: route.fallback(),
+    )
+
+    async def _goto_ignore_exceptions() -> None:
+        try:
+            await page.goto(server.EMPTY_PAGE)
+        except Error:
+            pass
+
+    asyncio.create_task(_goto_ignore_exceptions())
+    await route_future
+    await page.close()
+
+
+async def test_context_close_should_not_wait_for_active_route_handlers_on_the_owned_pages(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+    await page.route(
+        re.compile(".*"),
+        lambda route: route_future.set_result(route),
+    )
+    await page.route(re.compile(".*"), lambda route: route.fallback())
+
+    async def _goto_ignore_exceptions() -> None:
+        try:
+            await page.goto(server.EMPTY_PAGE)
+        except Error:
+            pass
+
+    asyncio.create_task(_goto_ignore_exceptions())
+    await route_future
+    await context.close()
+
+
+async def test_page_unroute_should_not_wait_for_pending_handlers_to_complete(
+    page: Page, server: Server
+) -> None:
+    second_handler_called = False
+
+    async def _handler1(route: Route) -> None:
+        nonlocal second_handler_called
+        second_handler_called = True
+        await route.continue_()
+
+    await page.route(
+        re.compile(".*"),
+        _handler1,
+    )
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+    route_barrier_future: "asyncio.Future[None]" = asyncio.Future()
+
+    async def _handler2(route: Route) -> None:
+        route_future.set_result(route)
+        await route_barrier_future
+        await route.fallback()
+
+    await page.route(
+        re.compile(".*"),
+        _handler2,
+    )
+    navigation_task = asyncio.create_task(page.goto(server.EMPTY_PAGE))
+    await route_future
+    await page.unroute(
+        re.compile(".*"),
+        _handler2,
+    )
+    route_barrier_future.set_result(None)
+    await navigation_task
+    assert second_handler_called
+
+
+async def test_page_unroute_all_removes_all_routes(page: Page, server: Server) -> None:
+    await page.route(
+        "**/*",
+        lambda route: route.abort(),
+    )
+    await page.route(
+        "**/empty.html",
+        lambda route: route.abort(),
+    )
+    await page.unroute_all()
+    response = must(await page.goto(server.EMPTY_PAGE))
+    assert response.ok
+
+
+async def test_page_unroute_should_wait_for_pending_handlers_to_complete(
+    page: Page, server: Server
+) -> None:
+    second_handler_called = False
+
+    async def _handler1(route: Route) -> None:
+        nonlocal second_handler_called
+        second_handler_called = True
+        await route.abort()
+
+    await page.route(
+        "**/*",
+        _handler1,
+    )
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+    route_barrier_future: "asyncio.Future[None]" = asyncio.Future()
+
+    async def _handler2(route: Route) -> None:
+        route_future.set_result(route)
+        await route_barrier_future
+        await route.fallback()
+
+    await page.route(
+        "**/*",
+        _handler2,
+    )
+    navigation_task = asyncio.create_task(page.goto(server.EMPTY_PAGE))
+    await route_future
+    did_unroute = False
+
+    async def _unroute_promise() -> None:
+        await page.unroute_all(behavior="wait")
+        nonlocal did_unroute
+        did_unroute = True
+
+    unroute_task = asyncio.create_task(_unroute_promise())
+    await asyncio.sleep(0.5)
+    assert did_unroute is False
+    route_barrier_future.set_result(None)
+    await unroute_task
+    assert did_unroute
+    await navigation_task
+    assert second_handler_called is False
+
+
+async def test_page_unroute_all_should_not_wait_for_pending_handlers_to_complete_if_behavior_is_ignore_errors(
+    page: Page, server: Server
+) -> None:
+    second_handler_called = False
+
+    async def _handler1(route: Route) -> None:
+        nonlocal second_handler_called
+        second_handler_called = True
+        await route.abort()
+
+    await page.route(re.compile(".*"), _handler1)
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+    route_barrier_future: "asyncio.Future[None]" = asyncio.Future()
+
+    async def _handler2(route: Route) -> None:
+        route_future.set_result(route)
+        await route_barrier_future
+        raise Exception("Handler error")
+
+    await page.route(re.compile(".*"), _handler2)
+    navigation_task = asyncio.create_task(page.goto(server.EMPTY_PAGE))
+    await route_future
+    did_unroute = False
+
+    async def _unroute_promise() -> None:
+        await page.unroute_all(behavior="ignoreErrors")
+        nonlocal did_unroute
+        did_unroute = True
+
+    unroute_task = asyncio.create_task(_unroute_promise())
+    await asyncio.sleep(0.5)
+    await unroute_task
+    assert did_unroute
+    route_barrier_future.set_result(None)
+    try:
+        await navigation_task
+    except Error:
+        pass
+    # The error in the unrouted handler should be silently caught.
+    assert not second_handler_called
+
+
+async def test_page_close_does_not_wait_for_active_route_handlers(
+    page: Page, server: Server
+) -> None:
+    stalling_future: "asyncio.Future[None]" = asyncio.Future()
+    second_handler_called = False
+
+    def _handler1(route: Route) -> None:
+        nonlocal second_handler_called
+        second_handler_called = True
+
+    await page.route(
+        "**/*",
+        _handler1,
+    )
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+
+    async def _handler2(route: Route) -> None:
+        route_future.set_result(route)
+        await stalling_future
+
+    await page.route(
+        "**/*",
+        _handler2,
+    )
+
+    async def _goto_ignore_exceptions() -> None:
+        try:
+            await page.goto(server.EMPTY_PAGE)
+        except Error:
+            pass
+
+    asyncio.create_task(_goto_ignore_exceptions())
+    await route_future
+    await page.close()
+    await asyncio.sleep(0.5)
+    assert not second_handler_called
+    stalling_future.cancel()
+
+
+async def test_route_continue_should_not_throw_if_page_has_been_closed(
+    page: Page, server: Server
+) -> None:
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+    await page.route(
+        re.compile(".*"),
+        lambda route: route_future.set_result(route),
+    )
+
+    async def _goto_ignore_exceptions() -> None:
+        try:
+            await page.goto(server.EMPTY_PAGE)
+        except Error:
+            pass
+
+    asyncio.create_task(_goto_ignore_exceptions())
+    route = await route_future
+    await page.close()
+    # Should not throw.
+    await route.continue_()
+
+
+async def test_route_fallback_should_not_throw_if_page_has_been_closed(
+    page: Page, server: Server
+) -> None:
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+    await page.route(
+        re.compile(".*"),
+        lambda route: route_future.set_result(route),
+    )
+
+    async def _goto_ignore_exceptions() -> None:
+        try:
+            await page.goto(server.EMPTY_PAGE)
+        except Error:
+            pass
+
+    asyncio.create_task(_goto_ignore_exceptions())
+    route = await route_future
+    await page.close()
+    # Should not throw.
+    await route.fallback()
+
+
+async def test_route_fulfill_should_not_throw_if_page_has_been_closed(
+    page: Page, server: Server
+) -> None:
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+    await page.route(
+        "**/*",
+        lambda route: route_future.set_result(route),
+    )
+
+    async def _goto_ignore_exceptions() -> None:
+        try:
+            await page.goto(server.EMPTY_PAGE)
+        except Error:
+            pass
+
+    asyncio.create_task(_goto_ignore_exceptions())
+    route = await route_future
+    await page.close()
+    # Should not throw.
+    await route.fulfill()
+
+
+async def test_should_not_continue_requests_in_flight_page(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+
+    async def handle(route: Route) -> None:
+        route_future.set_result(route)
+        await asyncio.sleep(3)
+        await route.fulfill(status=200)
+
+    async def _evaluate_ignore_exceptions() -> None:
+        try:
+            await page.evaluate("() => fetch('/')")
+        except Error:
+            pass
+
+    await page.route(
+        "**/*",
+        handle,
+    )
+
+    asyncio.create_task(_evaluate_ignore_exceptions())
+    await route_future
+    await page.unroute_all(behavior="wait")
+
+
+async def test_should_not_continue_requests_in_flight_context(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+
+    route_future: "asyncio.Future[Route]" = asyncio.Future()
+
+    async def handle(route: Route) -> None:
+        route_future.set_result(route)
+        await asyncio.sleep(3)
+        await route.fulfill(status=200)
+
+    async def _evaluate_ignore_exceptions() -> None:
+        try:
+            await page.evaluate("() => fetch('/')")
+        except Error:
+            pass
+
+    await context.route(
+        "**/*",
+        handle,
+    )
+
+    asyncio.create_task(_evaluate_ignore_exceptions())
+    await route_future
+    await context.unroute_all(behavior="wait")
diff --git a/tests/async/test_video.py b/tests/async/test_video.py
index 7242f6ef3..08d757794 100644
--- a/tests/async/test_video.py
+++ b/tests/async/test_video.py
@@ -13,33 +13,74 @@
 # limitations under the License.
 
 import os
+from pathlib import Path
+from typing import Dict
 
+from playwright.async_api import Browser, BrowserType
+from tests.server import Server
 
-async def test_should_expose_video_path(browser, tmpdir, server):
-    page = await browser.new_page(record_video_dir=tmpdir)
+
+async def test_should_expose_video_path(
+    browser: Browser, tmp_path: Path, server: Server
+) -> None:
+    page = await browser.new_page(record_video_dir=tmp_path)
     await page.goto(server.PREFIX + "/grid.html")
+    assert page.video
     path = await page.video.path()
-    assert str(tmpdir) in path
+    assert str(tmp_path) in str(path)
     await page.context.close()
 
 
-async def test_short_video_should_exist(browser, tmpdir, server):
-    page = await browser.new_page(record_video_dir=tmpdir)
+async def test_short_video_should_throw(
+    browser: Browser, tmp_path: Path, server: Server
+) -> None:
+    page = await browser.new_page(record_video_dir=tmp_path)
     await page.goto(server.PREFIX + "/grid.html")
+    assert page.video
     path = await page.video.path()
-    assert str(tmpdir) in path
+    assert str(tmp_path) in str(path)
+    await page.wait_for_timeout(1000)
     await page.context.close()
     assert os.path.exists(path)
 
 
-async def test_short_video_should_exist_persistent_context(browser_type, tmpdir):
+async def test_short_video_should_throw_persistent_context(
+    browser_type: BrowserType, tmp_path: Path, launch_arguments: Dict, server: Server
+) -> None:
     context = await browser_type.launch_persistent_context(
-        str(tmpdir),
-        viewport=(320, 240),
-        record_video_dir=str(tmpdir) + "1",
+        str(tmp_path),
+        **launch_arguments,
+        viewport={"width": 320, "height": 240},
+        record_video_dir=str(tmp_path) + "1",
     )
     page = context.pages[0]
+    await page.goto(server.PREFIX + "/grid.html")
+    await page.wait_for_timeout(1000)
     await context.close()
+
+    assert page.video
     path = await page.video.path()
-    assert str(tmpdir) in path
-    assert os.path.exists(path)
+    assert str(tmp_path) in str(path)
+
+
+async def test_should_not_error_if_page_not_closed_before_save_as(
+    browser: Browser, tmp_path: Path, server: Server
+) -> None:
+    page = await browser.new_page(record_video_dir=tmp_path)
+    await page.goto(server.PREFIX + "/grid.html")
+    await page.wait_for_timeout(1000)  # make sure video has some data
+    out_path = tmp_path / "some-video.webm"
+    assert page.video
+    saved = page.video.save_as(out_path)
+    await page.close()
+    await saved
+    await page.context.close()
+    assert os.path.exists(out_path)
+
+
+async def test_should_be_None_if_not_recording(
+    browser: Browser, tmp_path: Path, server: Server
+) -> None:
+    page = await browser.new_page()
+    assert page.video is None
+    await page.close()
diff --git a/tests/async/test_wait_for_function.py b/tests/async/test_wait_for_function.py
new file mode 100644
index 000000000..9d1171922
--- /dev/null
+++ b/tests/async/test_wait_for_function.py
@@ -0,0 +1,91 @@
+# 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.
+
+from datetime import datetime
+
+import pytest
+
+from playwright.async_api import ConsoleMessage, Error, Page
+
+
+async def test_should_timeout(page: Page) -> None:
+    start_time = datetime.now()
+    timeout = 42
+    await page.wait_for_timeout(timeout)
+    assert ((datetime.now() - start_time).microseconds * 1000) >= timeout / 2
+
+
+async def test_should_accept_a_string(page: Page) -> None:
+    watchdog = page.wait_for_function("window.__FOO === 1")
+    await page.evaluate("window['__FOO'] = 1")
+    await watchdog
+
+
+async def test_should_work_when_resolved_right_before_execution_context_disposal(
+    page: Page,
+) -> None:
+    await page.add_init_script("window['__RELOADED'] = true")
+    await page.wait_for_function(
+        """() => {
+            if (!window['__RELOADED'])
+                window.location.reload();
+            return true;
+        }"""
+    )
+
+
+async def test_should_poll_on_interval(page: Page) -> None:
+    polling = 100
+    time_delta = await page.wait_for_function(
+        """() => {
+            if (!window['__startTime']) {
+                window['__startTime'] = Date.now();
+                return false;
+            }
+            return Date.now() - window['__startTime'];
+        }""",
+        polling=polling,
+    )
+    assert await time_delta.json_value() >= polling
+
+
+async def test_should_avoid_side_effects_after_timeout(page: Page) -> None:
+    counter = 0
+
+    async def on_console(message: ConsoleMessage) -> None:
+        nonlocal counter
+        counter += 1
+
+    page.on("console", on_console)
+    with pytest.raises(Error) as exc_info:
+        await page.wait_for_function(
+            """() => {
+            window['counter'] = (window['counter'] || 0) + 1;
+            console.log(window['counter']);
+        }""",
+            polling=1,
+            timeout=1000,
+        )
+
+    saved_counter = counter
+    await page.wait_for_timeout(2000)  # Give it some time to produce more logs.
+
+    assert "Timeout 1000ms exceeded" in exc_info.value.message
+    assert counter == saved_counter
+
+
+async def test_should_throw_on_polling_mutation(page: Page) -> None:
+    with pytest.raises(Error) as exc_info:
+        await page.wait_for_function("() => true", polling="mutation")  # type: ignore
+    assert "Unknown polling option: mutation" in exc_info.value.message
diff --git a/tests/async/test_wait_for_url.py b/tests/async/test_wait_for_url.py
new file mode 100644
index 000000000..49e19b2d7
--- /dev/null
+++ b/tests/async/test_wait_for_url.py
@@ -0,0 +1,136 @@
+# 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 re
+
+import pytest
+
+from playwright.async_api import Error, Page
+from tests.server import Server
+
+
+async def test_wait_for_url_should_work(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate(
+        "url => window.location.href = url", server.PREFIX + "/grid.html"
+    )
+    await page.wait_for_url("**/grid.html")
+    assert "grid.html" in page.url
+
+
+async def test_wait_for_url_should_respect_timeout(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    with pytest.raises(Error) as exc_info:
+        await page.wait_for_url("**/frame.html", timeout=2500)
+    assert "Timeout 2500ms exceeded" in exc_info.value.message
+
+
+async def test_wait_for_url_should_work_with_both_domcontentloaded_and_load(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.wait_for_url("**/*", wait_until="domcontentloaded")
+    await page.wait_for_url("**/*", wait_until="load")
+
+
+async def test_wait_for_url_should_work_with_clicking_on_anchor_links(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content('<a href="#foobar">foobar</a>')
+    await page.click("a")
+    await page.wait_for_url("**/*#foobar")
+    assert page.url == server.EMPTY_PAGE + "#foobar"
+
+
+async def test_wait_for_url_should_work_with_history_push_state(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content(
+        """
+        <a onclick='javascript:pushState()'>SPA</a>
+        <script>
+            function pushState() { history.pushState({}, '', 'wow.html') }
+        </script>
+    """
+    )
+    await page.click("a")
+    await page.wait_for_url("**/wow.html")
+    assert page.url == server.PREFIX + "/wow.html"
+
+
+async def test_wait_for_url_should_work_with_history_replace_state(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content(
+        """
+        <a onclick='javascript:replaceState()'>SPA</a>
+        <script>
+            function replaceState() { history.replaceState({}, '', '/replaced.html') }
+        </script>
+    """
+    )
+    await page.click("a")
+    await page.wait_for_url("**/replaced.html")
+    assert page.url == server.PREFIX + "/replaced.html"
+
+
+async def test_wait_for_url_should_work_with_dom_history_back_forward(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.set_content(
+        """
+      <a id=back onclick='javascript:go_back()'>back</a>
+      <a id=forward onclick='javascript:go_forward()'>forward</a>
+      <script>
+        function go_back() { history.back(); }
+        function go_forward() { history.forward(); }
+        history.pushState({}, '', '/first.html')
+        history.pushState({}, '', '/second.html')
+      </script>
+    """
+    )
+
+    assert page.url == server.PREFIX + "/second.html"
+
+    await page.click("a#back")
+    await page.wait_for_url("**/first.html")
+    assert page.url == server.PREFIX + "/first.html"
+
+    await page.click("a#forward")
+    await page.wait_for_url("**/second.html")
+    assert page.url == server.PREFIX + "/second.html"
+
+
+async def test_wait_for_url_should_work_with_url_match_for_same_document_navigations(
+    page: Page, server: Server
+) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate("history.pushState({}, '', '/first.html')")
+    await page.evaluate("history.pushState({}, '', '/second.html')")
+    await page.evaluate("history.pushState({}, '', '/third.html')")
+    await page.wait_for_url(re.compile(r"third\.html"))
+    assert "/third.html" in page.url
+
+
+async def test_wait_for_url_should_work_with_commit(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    await page.evaluate(
+        "url => window.location.href = url", server.PREFIX + "/grid.html"
+    )
+    await page.wait_for_url("**/grid.html", wait_until="commit")
+    assert "grid.html" in page.url
diff --git a/tests/async/test_websocket.py b/tests/async/test_websocket.py
index 9ac0f5e4e..c4729a4a5 100644
--- a/tests/async/test_websocket.py
+++ b/tests/async/test_websocket.py
@@ -12,12 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
+from typing import Union
+
 import pytest
 
-from playwright.async_api import Error
+from playwright.async_api import Error, Page, WebSocket
+from tests.server import Server, WebSocketProtocol
 
 
-async def test_should_work(page, ws_server):
+async def test_should_work(page: Page, server: Server) -> None:
+    server.send_on_web_socket_connection(b"incoming")
     value = await page.evaluate(
         """port => {
         let cb;
@@ -26,68 +31,107 @@ async def test_should_work(page, ws_server):
         ws.addEventListener('message', data => { ws.close(); cb(data.data); });
         return result;
     }""",
-        ws_server.PORT,
+        server.PORT,
     )
     assert value == "incoming"
     pass
 
 
-async def test_should_emit_close_events(page, ws_server):
-    async with page.expect_event("websocket") as ws_info:
+async def test_should_emit_close_events(page: Page, server: Server) -> None:
+    await page.goto(server.EMPTY_PAGE)
+    close_future: asyncio.Future[None] = asyncio.Future()
+    async with page.expect_websocket() as ws_info:
         await page.evaluate(
             """port => {
-            let cb;
-            const result = new Promise(f => cb = f);
             const ws = new WebSocket('ws://localhost:' + port + '/ws');
-            ws.addEventListener('message', data => { ws.close(); cb(data.data); });
-            return result;
+            ws.addEventListener('open', data => ws.close());
         }""",
-            ws_server.PORT,
+            server.PORT,
         )
     ws = await ws_info.value
-    assert ws.url == f"ws://localhost:{ws_server.PORT}/ws"
-    if not ws.is_closed():
-        await ws.wait_for_event("close")
+    ws.on("close", lambda ws: close_future.set_result(None))
+    assert ws.url == f"ws://localhost:{server.PORT}/ws"
+    assert repr(ws) == f"<WebSocket url={ws.url!r}>"
+    await close_future
     assert ws.is_closed()
 
 
-async def test_should_emit_frame_events(page, ws_server):
-    sent = []
-    received = []
+async def test_should_emit_frame_events(page: Page, server: Server) -> None:
+    def _handle_ws_connection(ws: WebSocketProtocol) -> None:
+        def _onMessage(payload: bytes, isBinary: bool) -> None:
+            ws.sendMessage(b"incoming", False)
+            ws.sendClose()
 
-    def on_web_socket(ws):
-        ws.on("framesent", lambda payload: sent.append(payload))
-        ws.on("framereceived", lambda payload: received.append(payload))
+        setattr(ws, "onMessage", _onMessage)
+
+    server.once_web_socket_connection(_handle_ws_connection)
+    log = []
+    socket_close_future: "asyncio.Future[None]" = asyncio.Future()
+
+    def on_web_socket(ws: WebSocket) -> None:
+        log.append("open")
+
+        def _on_framesent(payload: Union[bytes, str]) -> None:
+            assert isinstance(payload, str)
+            log.append(f"sent<{payload}>")
+
+        ws.on("framesent", _on_framesent)
+
+        def _on_framereceived(payload: Union[bytes, str]) -> None:
+            assert isinstance(payload, str)
+            log.append(f"received<{payload}>")
+
+        ws.on("framereceived", _on_framereceived)
+
+        def _handle_close(ws: WebSocket) -> None:
+            log.append("close")
+            socket_close_future.set_result(None)
+
+        ws.on("close", _handle_close)
 
     page.on("websocket", on_web_socket)
-    async with page.expect_event("websocket") as ws_info:
+    async with page.expect_event("websocket"):
         await page.evaluate(
             """port => {
             const ws = new WebSocket('ws://localhost:' + port + '/ws');
-            ws.addEventListener('open', () => {
-                ws.send('echo-text');
-            });
+            ws.addEventListener('open', () => ws.send('outgoing'));
+            ws.addEventListener('message', () => ws.close())
         }""",
-            ws_server.PORT,
+            server.PORT,
         )
-    ws = await ws_info.value
-    if not ws.is_closed():
-        await ws.wait_for_event("close")
+    await socket_close_future
+    assert log[0] == "open"
+    assert log[3] == "close"
+    log.sort()
+    assert log == ["close", "open", "received<incoming>", "sent<outgoing>"]
+
 
-    assert sent == ["echo-text"]
-    assert received == ["incoming", "text"]
+async def test_should_emit_binary_frame_events(page: Page, server: Server) -> None:
+    def _handle_ws_connection(ws: WebSocketProtocol) -> None:
+        ws.sendMessage(b"incoming")
 
+        def _onMessage(payload: bytes, isBinary: bool) -> None:
+            if payload == b"echo-bin":
+                ws.sendMessage(b"\x04\x02", True)
+                ws.sendClose()
+            if payload == b"echo-text":
+                ws.sendMessage(b"text", False)
+                ws.sendClose()
 
-async def test_should_emit_binary_frame_events(page, ws_server):
+        setattr(ws, "onMessage", _onMessage)
+
+    server.once_web_socket_connection(_handle_ws_connection)
+    done_task: "asyncio.Future[None]" = asyncio.Future()
     sent = []
     received = []
 
-    def on_web_socket(ws):
+    def on_web_socket(ws: WebSocket) -> None:
         ws.on("framesent", lambda payload: sent.append(payload))
         ws.on("framereceived", lambda payload: received.append(payload))
+        ws.on("close", lambda _: done_task.set_result(None))
 
     page.on("websocket", on_web_socket)
-    async with page.expect_event("websocket") as ws_info:
+    async with page.expect_event("websocket"):
         await page.evaluate(
             """port => {
             const ws = new WebSocket('ws://localhost:' + port + '/ws');
@@ -99,23 +143,23 @@ def on_web_socket(ws):
                 ws.send('echo-bin');
             });
         }""",
-            ws_server.PORT,
+            server.PORT,
         )
-    ws = await ws_info.value
-    if not ws.is_closed():
-        await ws.wait_for_event("close")
+    await done_task
     assert sent == [b"\x00\x01\x02\x03\x04", "echo-bin"]
     assert received == ["incoming", b"\x04\x02"]
 
 
-@pytest.mark.skip_browser("webkit")  # Flakes on bots
-async def test_should_reject_wait_for_event_on_close_and_error(page, ws_server):
+async def test_should_reject_wait_for_event_on_close_and_error(
+    page: Page, server: Server
+) -> None:
+    server.send_on_web_socket_connection(b"incoming")
     async with page.expect_event("websocket") as ws_info:
         await page.evaluate(
             """port => {
             window.ws = new WebSocket('ws://localhost:' + port + '/ws');
         }""",
-            ws_server.PORT,
+            server.PORT,
         )
     ws = await ws_info.value
     await ws.wait_for_event("framereceived")
@@ -123,3 +167,29 @@ async def test_should_reject_wait_for_event_on_close_and_error(page, ws_server):
         async with ws.expect_event("framesent"):
             await page.evaluate("window.ws.close()")
     assert exc_info.value.message == "Socket closed"
+
+
+async def test_should_emit_error_event(
+    page: Page, server: Server, browser_name: str, browser_channel: str
+) -> None:
+    future: "asyncio.Future[str]" = asyncio.Future()
+
+    def _on_ws_socket_error(err: str) -> None:
+        future.set_result(err)
+
+    def _on_websocket(websocket: WebSocket) -> None:
+        websocket.on("socketerror", _on_ws_socket_error)
+
+    page.on(
+        "websocket",
+        _on_websocket,
+    )
+    await page.evaluate(
+        """port => new WebSocket(`ws://localhost:${port}/bogus-ws`)""",
+        server.PORT,
+    )
+    err = await future
+    if browser_name == "firefox":
+        assert err == "CLOSE_ABNORMAL"
+    else:
+        assert ("" if browser_channel == "msedge" else ": 404") in err
diff --git a/tests/async/test_worker.py b/tests/async/test_worker.py
index 73454b844..4c2e4ebeb 100644
--- a/tests/async/test_worker.py
+++ b/tests/async/test_worker.py
@@ -1,6 +1,6 @@
 # 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
 #
@@ -17,15 +17,17 @@
 
 import pytest
 
-from playwright.async_api import Error, Page, Worker
+from playwright.async_api import Browser, ConsoleMessage, Error, Page, Worker
+from tests.server import Server
+from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
 
 
-async def test_workers_page_workers(page, server):
-    await asyncio.gather(
-        page.wait_for_event("worker"), page.goto(server.PREFIX + "/worker/worker.html")
-    )
-    worker = page.workers[0]
+async def test_workers_page_workers(page: Page, server: Server) -> None:
+    async with page.expect_worker() as worker_info:
+        await page.goto(server.PREFIX + "/worker/worker.html")
+    worker = await worker_info.value
     assert "worker.js" in worker.url
+    assert repr(worker) == f"<Worker url={worker.url!r}>"
 
     assert (
         await worker.evaluate('() => self["workerFunction"]()')
@@ -36,7 +38,7 @@ async def test_workers_page_workers(page, server):
     assert len(page.workers) == 0
 
 
-async def test_workers_should_emit_created_and_destroyed_events(page: Page):
+async def test_workers_should_emit_created_and_destroyed_events(page: Page) -> None:
     worker_obj = None
     async with page.expect_event("worker") as event_info:
         worker_obj = await page.evaluate_handle(
@@ -50,33 +52,36 @@ async def test_workers_should_emit_created_and_destroyed_events(page: Page):
     assert await worker_destroyed_promise == worker
     with pytest.raises(Error) as exc:
         await worker_this_obj.get_property("self")
-    assert "Most likely the worker has been closed." in exc.value.message
+    assert TARGET_CLOSED_ERROR_MESSAGE in exc.value.message
 
 
-async def test_workers_should_report_console_logs(page):
-    [message, _] = await asyncio.gather(
-        page.wait_for_event("console"),
-        page.evaluate(
+async def test_workers_should_report_console_logs(page: Page) -> None:
+    async with page.expect_console_message() as message_info:
+        await page.evaluate(
             '() => new Worker(URL.createObjectURL(new Blob(["console.log(1)"], {type: "application/javascript"})))'
-        ),
-    )
+        )
+    message = await message_info.value
     assert message.text == "1"
 
 
-@pytest.mark.skip_browser("firefox")  # TODO: investigate further @pavelfeldman
-async def test_workers_should_have_JSHandles_for_console_logs(page):
-    log_promise = asyncio.Future()
+async def test_workers_should_have_JSHandles_for_console_logs(
+    page: Page, browser_name: str
+) -> None:
+    log_promise: "asyncio.Future[ConsoleMessage]" = asyncio.Future()
     page.on("console", lambda m: log_promise.set_result(m))
     await page.evaluate(
         "() => new Worker(URL.createObjectURL(new Blob(['console.log(1,2,3,this)'], {type: 'application/javascript'})))"
     )
     log = await log_promise
-    assert log.text == "1 2 3 JSHandle@object"
+    if browser_name != "firefox":
+        assert log.text == "1 2 3 DedicatedWorkerGlobalScope"
+    else:
+        assert log.text == "1 2 3 JSHandle@object"
     assert len(log.args) == 4
     assert await (await log.args[3].get_property("origin")).json_value() == "null"
 
 
-async def test_workers_should_evaluate(page):
+async def test_workers_should_evaluate(page: Page) -> None:
     async with page.expect_event("worker") as event_info:
         await page.evaluate(
             "() => new Worker(URL.createObjectURL(new Blob(['console.log(1)'], {type: 'application/javascript'})))"
@@ -85,8 +90,8 @@ async def test_workers_should_evaluate(page):
     assert await worker.evaluate("1+1") == 2
 
 
-async def test_workers_should_report_errors(page):
-    error_promise = asyncio.Future()
+async def test_workers_should_report_errors(page: Page) -> None:
+    error_promise: "asyncio.Future[Error]" = asyncio.Future()
     page.on("pageerror", lambda e: error_promise.set_result(e))
     await page.evaluate(
         """() => new Worker(URL.createObjectURL(new Blob([`
@@ -101,8 +106,7 @@ async def test_workers_should_report_errors(page):
     assert "this is my error" in error_log.message
 
 
-@pytest.mark.skip_browser("firefox")  # TODO: fails upstream
-async def test_workers_should_clear_upon_navigation(server, page):
+async def test_workers_should_clear_upon_navigation(server: Server, page: Page) -> None:
     await page.goto(server.EMPTY_PAGE)
     async with page.expect_event("worker") as event_info:
         await page.evaluate(
@@ -117,8 +121,9 @@ async def test_workers_should_clear_upon_navigation(server, page):
     assert len(page.workers) == 0
 
 
-@pytest.mark.skip_browser("firefox")  # TODO: fails upstream
-async def test_workers_should_clear_upon_cross_process_navigation(server, page):
+async def test_workers_should_clear_upon_cross_process_navigation(
+    server: Server, page: Page
+) -> None:
     await page.goto(server.EMPTY_PAGE)
     async with page.expect_event("worker") as event_info:
         await page.evaluate(
@@ -133,15 +138,20 @@ async def test_workers_should_clear_upon_cross_process_navigation(server, page):
     assert len(page.workers) == 0
 
 
-async def test_workers_should_report_network_activity(page, server):
-    [worker, _] = await asyncio.gather(
-        page.wait_for_event("worker"),
-        page.goto(server.PREFIX + "/worker/worker.html"),
-    )
+@pytest.mark.skip_browser(
+    "firefox"
+)  # https://github.com/microsoft/playwright/issues/21760
+async def test_workers_should_report_network_activity(
+    page: Page, server: Server
+) -> None:
+    async with page.expect_worker() as worker_info:
+        await page.goto(server.PREFIX + "/worker/worker.html")
+    worker = await worker_info.value
     url = server.PREFIX + "/one-style.css"
-    async with page.expect_request(url) as request_info, page.expect_response(
-        url
-    ) as response_info:
+    async with (
+        page.expect_request(url) as request_info,
+        page.expect_response(url) as response_info,
+    ):
         await worker.evaluate(
             "url => fetch(url).then(response => response.text()).then(console.log)", url
         )
@@ -152,13 +162,19 @@ async def test_workers_should_report_network_activity(page, server):
     assert response.ok
 
 
-async def test_workers_should_report_network_activity_on_worker_creation(page, server):
+@pytest.mark.skip_browser(
+    "firefox"
+)  # https://github.com/microsoft/playwright/issues/21760
+async def test_workers_should_report_network_activity_on_worker_creation(
+    page: Page, server: Server
+) -> None:
     # Chromium needs waitForDebugger enabled for this one.
     await page.goto(server.EMPTY_PAGE)
     url = server.PREFIX + "/one-style.css"
-    async with page.expect_request(url) as request_info, page.expect_response(
-        url
-    ) as response_info:
+    async with (
+        page.expect_request(url) as request_info,
+        page.expect_response(url) as response_info,
+    ):
         await page.evaluate(
             """url => new Worker(URL.createObjectURL(new Blob([`
         fetch("${url}").then(response => response.text()).then(console.log);
@@ -172,15 +188,57 @@ async def test_workers_should_report_network_activity_on_worker_creation(page, s
     assert response.ok
 
 
-async def test_workers_should_format_number_using_context_locale(browser, server):
+async def test_workers_should_format_number_using_context_locale(
+    browser: Browser, server: Server, browser_name: str
+) -> None:
     context = await browser.new_context(locale="ru-RU")
     page = await context.new_page()
     await page.goto(server.EMPTY_PAGE)
-    [worker, _] = await asyncio.gather(
-        page.wait_for_event("worker"),
-        page.evaluate(
+    async with page.expect_worker() as worker_info:
+        await page.evaluate(
             "() => new Worker(URL.createObjectURL(new Blob(['console.log(1)'], {type: 'application/javascript'})))"
-        ),
-    )
-    assert await worker.evaluate("() => (10000.20).toLocaleString()") == "10\u00A0000,2"
+        )
+    worker = await worker_info.value
+    # https://github.com/microsoft/playwright/issues/38919
+    expected = "10,000.2" if browser_name == "firefox" else "10\u00a0000,2"
+    assert await worker.evaluate("() => (10000.20).toLocaleString()") == expected
     await context.close()
+
+
+async def test_worker_should_report_console_event(page: Page) -> None:
+    async with page.expect_worker() as worker_info:
+        await page.evaluate(
+            "() => { window.worker = new Worker(URL.createObjectURL(new Blob(['42'], { type: 'application/javascript' }))); }"
+        )
+    worker = await worker_info.value
+
+    async with worker.expect_event("console") as message1_info:
+        async with page.expect_console_message() as message2_info:
+            async with page.context.expect_console_message() as message3_info:
+                await worker.evaluate("() => { console.log('hello from worker'); }")
+
+    message1 = await message1_info.value
+    message2 = await message2_info.value
+    message3 = await message3_info.value
+
+    assert message1.text == "hello from worker"
+    assert message1 is message2
+    assert message1 is message3
+    assert message1.worker is worker
+
+
+async def test_worker_should_report_console_event_when_not_listening_on_page_or_context(
+    page: Page,
+) -> None:
+    async with page.expect_worker() as worker_info:
+        await page.evaluate(
+            "() => { window.worker = new Worker(URL.createObjectURL(new Blob(['42'], { type: 'application/javascript' }))); }"
+        )
+    worker = await worker_info.value
+
+    async with worker.expect_event("console") as message_info:
+        await worker.evaluate("() => { console.log('hello from worker'); }")
+
+    message = await message_info.value
+    assert message.text == "hello from worker"
+    assert message.worker is worker
diff --git a/tests/async/utils.py b/tests/async/utils.py
new file mode 100644
index 000000000..c253eb1ca
--- /dev/null
+++ b/tests/async/utils.py
@@ -0,0 +1,79 @@
+# 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 re
+from typing import Any, List, cast
+
+from playwright.async_api import (
+    ElementHandle,
+    Error,
+    Frame,
+    Page,
+    Selectors,
+    ViewportSize,
+)
+
+
+class Utils:
+    async def attach_frame(self, page: Page, frame_id: str, url: str) -> Frame:
+        handle = await page.evaluate_handle(
+            """async ({ frame_id, url }) => {
+                const frame = document.createElement('iframe');
+                frame.src = url;
+                frame.id = frame_id;
+                document.body.appendChild(frame);
+                await new Promise(x => frame.onload = x);
+                return frame;
+            }""",
+            {"frame_id": frame_id, "url": url},
+        )
+        frame = await cast(ElementHandle, handle.as_element()).content_frame()
+        assert frame
+        return frame
+
+    async def detach_frame(self, page: Page, frame_id: str) -> None:
+        await page.evaluate(
+            "frame_id => document.getElementById(frame_id).remove()", frame_id
+        )
+
+    def dump_frames(self, frame: Frame, indentation: str = "") -> List[str]:
+        indentation = indentation or ""
+        description = re.sub(r":\d+/", ":<PORT>/", frame.url)
+        if frame.name:
+            description += " (" + frame.name + ")"
+        result = [indentation + description]
+        sorted_frames = sorted(
+            frame.child_frames, key=lambda frame: frame.url + frame.name
+        )
+        for child in sorted_frames:
+            result = result + utils.dump_frames(child, "    " + indentation)
+        return result
+
+    async def verify_viewport(self, page: Page, width: int, height: int) -> None:
+        assert cast(ViewportSize, page.viewport_size)["width"] == width
+        assert cast(ViewportSize, page.viewport_size)["height"] == height
+        assert await page.evaluate("window.innerWidth") == width
+        assert await page.evaluate("window.innerHeight") == height
+
+    async def register_selector_engine(
+        self, selectors: Selectors, *args: Any, **kwargs: Any
+    ) -> None:
+        try:
+            await selectors.register(*args, **kwargs)
+        except Error as exc:
+            if "has been already registered" not in exc.message:
+                raise exc
+
+
+utils = Utils()
diff --git a/tests/common/test_collect_handles.py b/tests/common/test_collect_handles.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/common/test_events.py b/tests/common/test_events.py
new file mode 100644
index 000000000..07d6c4e2b
--- /dev/null
+++ b/tests/common/test_events.py
@@ -0,0 +1,32 @@
+# 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.
+from typing import Dict
+
+import pytest
+
+from playwright.sync_api import sync_playwright
+from tests.server import Server
+
+
+def test_events(browser_name: str, launch_arguments: Dict, server: Server) -> None:
+    with pytest.raises(Exception, match="fail"):
+
+        def fail() -> None:
+            raise Exception("fail")
+
+        with sync_playwright() as p:
+            with p[browser_name].launch(**launch_arguments) as browser:
+                with browser.new_page() as page:
+                    page.on("response", lambda _: fail())
+                    page.goto(server.PREFIX + "/grid.html")
diff --git a/tests/common/test_signals.py b/tests/common/test_signals.py
new file mode 100644
index 000000000..ba600b44d
--- /dev/null
+++ b/tests/common/test_signals.py
@@ -0,0 +1,145 @@
+# 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 asyncio
+import multiprocessing
+import os
+import signal
+import sys
+from typing import Any, Dict
+
+import pytest
+
+from playwright.async_api import async_playwright
+from playwright.sync_api import sync_playwright
+
+
+def _test_signals_async(
+    browser_name: str, launch_arguments: Dict, wait_queue: "multiprocessing.Queue[str]"
+) -> None:
+    # On Windows, hint to mypy and pyright that they shouldn't check this function
+    if sys.platform == "win32":
+        return
+
+    os.setpgrp()
+    sigint_received = False
+
+    def my_sig_handler(signum: int, frame: Any) -> None:
+        nonlocal sigint_received
+        sigint_received = True
+
+    signal.signal(signal.SIGINT, my_sig_handler)
+
+    async def main() -> None:
+        playwright = await async_playwright().start()
+        browser = await playwright[browser_name].launch(
+            **launch_arguments,
+            handle_sigint=False,
+        )
+        context = await browser.new_context()
+        page = await context.new_page()
+        notified = False
+        try:
+            while not sigint_received:
+                if not notified:
+                    wait_queue.put("ready")
+                    notified = True
+                await page.wait_for_timeout(100)
+        finally:
+            wait_queue.put("close context")
+            await context.close()
+            wait_queue.put("close browser")
+            await browser.close()
+            wait_queue.put("close playwright")
+            await playwright.stop()
+            wait_queue.put("all done")
+
+    asyncio.run(main())
+
+
+def _test_signals_sync(
+    browser_name: str, launch_arguments: Dict, wait_queue: "multiprocessing.Queue[str]"
+) -> None:
+    # On Windows, hint to mypy and pyright that they shouldn't check this function
+    if sys.platform == "win32":
+        return
+
+    os.setpgrp()
+    sigint_received = False
+
+    def my_sig_handler(signum: int, frame: Any) -> None:
+        nonlocal sigint_received
+        sigint_received = True
+
+    signal.signal(signal.SIGINT, my_sig_handler)
+
+    playwright = sync_playwright().start()
+    browser = playwright[browser_name].launch(
+        **launch_arguments,
+        handle_sigint=False,
+    )
+    context = browser.new_context()
+    page = context.new_page()
+    notified = False
+    try:
+        while not sigint_received:
+            if not notified:
+                wait_queue.put("ready")
+                notified = True
+            page.wait_for_timeout(100)
+    finally:
+        wait_queue.put("close context")
+        context.close()
+        wait_queue.put("close browser")
+        browser.close()
+        wait_queue.put("close playwright")
+        playwright.stop()
+        wait_queue.put("all done")
+
+
+def _create_signals_test(
+    target: Any, browser_name: str, launch_arguments: Dict
+) -> None:
+    # On Windows, hint to mypy and pyright that they shouldn't check this function
+    if sys.platform == "win32":
+        return
+
+    wait_queue: "multiprocessing.Queue[str]" = multiprocessing.Queue()
+    process = multiprocessing.Process(
+        target=target, args=[browser_name, launch_arguments, wait_queue]
+    )
+    process.start()
+    assert process.pid is not None
+    logs = [wait_queue.get()]
+    os.killpg(os.getpgid(process.pid), signal.SIGINT)
+    process.join()
+    while not wait_queue.empty():
+        logs.append(wait_queue.get())
+    assert logs == [
+        "ready",
+        "close context",
+        "close browser",
+        "close playwright",
+        "all done",
+    ]
+    assert process.exitcode == 0
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="there is no SIGINT on Windows")
+def test_signals_sync(browser_name: str, launch_arguments: Dict) -> None:
+    _create_signals_test(_test_signals_sync, browser_name, launch_arguments)
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="there is no SIGINT on Windows")
+def test_signals_async(browser_name: str, launch_arguments: Dict) -> None:
+    _create_signals_test(_test_signals_async, browser_name, launch_arguments)
diff --git a/tests/common/test_threads.py b/tests/common/test_threads.py
index dcbbfc61d..b957244f2 100644
--- a/tests/common/test_threads.py
+++ b/tests/common/test_threads.py
@@ -1,6 +1,6 @@
 # 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
 #
@@ -13,17 +13,18 @@
 # limitations under the License.
 
 import threading
+from typing import Dict
 
 from playwright.sync_api import sync_playwright
 
 
-def test_running_in_thread(browser_name):
+def test_running_in_thread(browser_name: str, launch_arguments: Dict) -> None:
     result = []
 
     class TestThread(threading.Thread):
-        def run(self):
+        def run(self) -> None:
             with sync_playwright() as playwright:
-                browser = getattr(playwright, browser_name).launch()
+                browser = playwright[browser_name].launch(**launch_arguments)
                 # This should not throw ^^.
                 browser.new_page()
                 browser.close()
diff --git a/tests/conftest.py b/tests/conftest.py
index c327bccd4..d12a065c0 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,6 +1,6 @@
 # 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
 #
@@ -12,118 +12,134 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import asyncio
+import inspect
 import io
+import json
+import os
+import subprocess
 import sys
+from pathlib import Path
+from typing import Any, Callable, Dict, Generator, List, Optional, cast
 
 import pytest
+from _pytest.terminal import TerminalReporter
 from PIL import Image
 from pixelmatch import pixelmatch
 from pixelmatch.contrib.PIL import from_PIL_to_raw_data
 
+import playwright
 from playwright._impl._path_utils import get_file_dirname
 
-from .server import test_server
-from .utils import utils as utils_object
+from .server import Server, test_server
 
 _dirname = get_file_dirname()
 
 
-def pytest_generate_tests(metafunc):
+def pytest_configure(config: pytest.Config) -> None:
+    if os.environ.get("CI"):
+        config.option.reruns = 3
+
+
+def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
     if "browser_name" in metafunc.fixturenames:
         browsers = metafunc.config.option.browser or ["chromium", "firefox", "webkit"]
         metafunc.parametrize("browser_name", browsers, scope="session")
 
 
 @pytest.fixture(scope="session")
-def event_loop():
-    loop = asyncio.get_event_loop()
-    yield loop
-    loop.close()
+def assetdir() -> Path:
+    return _dirname / "assets"
 
 
 @pytest.fixture(scope="session")
-def assetdir():
-    return _dirname / "assets"
+def headless(pytestconfig: pytest.Config) -> bool:
+    return not (pytestconfig.getoption("--headed") or os.getenv("HEADFUL", False))
 
 
 @pytest.fixture(scope="session")
-def launch_arguments(pytestconfig):
-    return {
-        "headless": not pytestconfig.getoption("--headful"),
-        "chromium_sandbox": False,
+def launch_arguments(pytestconfig: pytest.Config, headless: bool) -> Dict:
+    args: Dict = {
+        "headless": headless,
     }
+    if pytestconfig.getoption("--browser-channel"):
+        args["channel"] = pytestconfig.getoption("--browser-channel")
+    return args
 
 
 @pytest.fixture
-def server():
+def server() -> Generator[Server, None, None]:
     yield test_server.server
 
 
 @pytest.fixture
-def https_server():
+def https_server() -> Generator[Server, None, None]:
     yield test_server.https_server
 
 
-@pytest.fixture
-def ws_server():
-    yield test_server.ws_server
-
-
-@pytest.fixture
-def utils():
-    yield utils_object
-
-
 @pytest.fixture(autouse=True, scope="session")
-async def start_server():
+def start_server() -> Generator[None, None, None]:
     test_server.start()
     yield
     test_server.stop()
 
 
 @pytest.fixture(autouse=True)
-def after_each_hook():
+def after_each_hook() -> Generator[None, None, None]:
     yield
     test_server.reset()
 
 
 @pytest.fixture(scope="session")
-def browser_name(pytestconfig):
-    return pytestconfig.getoption("browser")
+def browser_name(pytestconfig: pytest.Config) -> str:
+    return cast(str, pytestconfig.getoption("browser"))
 
 
 @pytest.fixture(scope="session")
-def is_webkit(browser_name):
+def browser_channel(pytestconfig: pytest.Config) -> Optional[str]:
+    return cast(Optional[str], pytestconfig.getoption("--browser-channel"))
+
+
+@pytest.fixture(scope="session")
+def is_headless_shell(browser_name: str, browser_channel: str, headless: bool) -> bool:
+    return browser_name == "chromium" and (
+        browser_channel == "chromium-headless-shell"
+        or (not browser_channel and headless)
+    )
+
+
+@pytest.fixture(scope="session")
+def is_webkit(browser_name: str) -> bool:
     return browser_name == "webkit"
 
 
 @pytest.fixture(scope="session")
-def is_firefox(browser_name):
+def is_firefox(browser_name: str) -> bool:
     return browser_name == "firefox"
 
 
 @pytest.fixture(scope="session")
-def is_chromium(browser_name):
+def is_chromium(browser_name: str) -> bool:
     return browser_name == "chromium"
 
 
 @pytest.fixture(scope="session")
-def is_win():
+def is_win() -> bool:
     return sys.platform == "win32"
 
 
 @pytest.fixture(scope="session")
-def is_linux():
+def is_linux() -> bool:
     return sys.platform == "linux"
 
 
 @pytest.fixture(scope="session")
-def is_mac():
+def is_mac() -> bool:
     return sys.platform == "darwin"
 
 
-def _get_skiplist(request, values, value_name):
+def _get_skiplist(
+    request: pytest.FixtureRequest, values: List[str], value_name: str
+) -> List[str]:
     skipped_values = []
     # Allowlist
     only_marker = request.node.get_closest_marker(f"only_{value_name}")
@@ -140,7 +156,7 @@ def _get_skiplist(request, values, value_name):
 
 
 @pytest.fixture(autouse=True)
-def skip_by_browser(request, browser_name):
+def skip_by_browser(request: pytest.FixtureRequest, browser_name: str) -> None:
     skip_browsers_names = _get_skiplist(
         request, ["chromium", "firefox", "webkit"], "browser"
     )
@@ -150,7 +166,7 @@ def skip_by_browser(request, browser_name):
 
 
 @pytest.fixture(autouse=True)
-def skip_by_platform(request):
+def skip_by_platform(request: pytest.FixtureRequest) -> None:
     skip_platform_names = _get_skiplist(
         request, ["win32", "linux", "darwin"], "platform"
     )
@@ -159,7 +175,7 @@ def skip_by_platform(request):
         pytest.skip(f"skipped on this platform: {sys.platform}")
 
 
-def pytest_addoption(parser):
+def pytest_addoption(parser: pytest.Parser) -> None:
     group = parser.getgroup("playwright", "Playwright")
     group.addoption(
         "--browser",
@@ -167,31 +183,125 @@ def pytest_addoption(parser):
         default=[],
         help="Browsers which should be used. By default on all the browsers.",
     )
+    group.addoption(
+        "--browser-channel",
+        action="store",
+        default=None,
+        help="Browser channel to be used.",
+    )
     parser.addoption(
-        "--headful",
+        "--headed",
         action="store_true",
         default=False,
-        help="Run tests in headful mode.",
+        help="Run tests in headed mode.",
     )
 
 
 @pytest.fixture(scope="session")
-def assert_to_be_golden(browser_name: str):
-    def compare(received_raw: bytes, golden_name: str):
-        golden_file = (_dirname / f"golden-{browser_name}" / golden_name).read_bytes()
-        received_image = Image.open(io.BytesIO(received_raw))
-        golden_image = Image.open(io.BytesIO(golden_file))
-
-        if golden_image.size != received_image.size:
-            pytest.fail("Image size differs to golden image")
+def assert_to_be_golden(browser_name: str) -> Callable[[bytes, str], None]:
+    def compare(received_raw: bytes, golden_name: str) -> None:
+        golden_file_path = _dirname / f"golden-{browser_name}" / golden_name
+        try:
+            golden_file = golden_file_path.read_bytes()
+            received_image = Image.open(io.BytesIO(received_raw))
+            golden_image = Image.open(io.BytesIO(golden_file))
+
+            if golden_image.size != received_image.size:
+                pytest.fail("Image size differs to golden image")
+                return
+            diff_pixels = pixelmatch(
+                from_PIL_to_raw_data(received_image),
+                from_PIL_to_raw_data(golden_image),
+                golden_image.size[0],
+                golden_image.size[1],
+                threshold=0.2,
+            )
+            assert diff_pixels == 0
+        except Exception:
+            if os.getenv("PW_WRITE_SCREENSHOT"):
+                golden_file_path.parent.mkdir(parents=True, exist_ok=True)
+                golden_file_path.write_bytes(received_raw)
+                print(f"Wrote {golden_file_path}")
+            raise
+
+    return compare
+
+
+class RemoteServer:
+    def __init__(
+        self, browser_name: str, launch_server_options: Dict, tmpfile: Path
+    ) -> None:
+        driver_dir = Path(inspect.getfile(playwright)).parent / "driver"
+        if sys.platform == "win32":
+            node_executable = driver_dir / "node.exe"
+        else:
+            node_executable = driver_dir / "node"
+        cli_js = driver_dir / "package" / "cli.js"
+        tmpfile.write_text(json.dumps(launch_server_options))
+        self.process = subprocess.Popen(
+            [
+                str(node_executable),
+                str(cli_js),
+                "launch-server",
+                "--browser",
+                browser_name,
+                "--config",
+                str(tmpfile),
+            ],
+            stdout=subprocess.PIPE,
+            stderr=sys.stderr,
+            cwd=driver_dir,
+        )
+        assert self.process.stdout
+        self.ws_endpoint = self.process.stdout.readline().decode().strip()
+        self.process.stdout.close()
+
+    def kill(self) -> None:
+        # Send the signal to all the process groups
+        if self.process.poll() is not None:
             return
-        diff_pixels = pixelmatch(
-            from_PIL_to_raw_data(received_image),
-            from_PIL_to_raw_data(golden_image),
-            golden_image.size[0],
-            golden_image.size[1],
-            threshold=0.2,
+        self.process.kill()
+        self.process.wait()
+
+
+_failed_node_ids: List[str] = []
+
+
+def pytest_runtest_logreport(report: pytest.TestReport) -> None:
+    if report.failed and report.when in ("setup", "call"):
+        if report.nodeid not in _failed_node_ids:
+            _failed_node_ids.append(report.nodeid)
+
+
+def pytest_terminal_summary(
+    terminalreporter: TerminalReporter, exitstatus: int, config: pytest.Config
+) -> None:
+    if not _failed_node_ids:
+        return
+    terminalreporter.write_sep("=", "Failed tests", red=True, bold=True)
+    for index, nodeid in enumerate(_failed_node_ids, 1):
+        terminalreporter.write_line(f"  {index}) {nodeid}", red=True)
+
+
+@pytest.fixture
+def launch_server(
+    browser_name: str, launch_arguments: Dict, tmp_path: Path
+) -> Generator[Callable[..., RemoteServer], None, None]:
+    remotes: List[RemoteServer] = []
+
+    def _launch_server(**kwargs: Dict[str, Any]) -> RemoteServer:
+        remote = RemoteServer(
+            browser_name,
+            {
+                **launch_arguments,
+                **kwargs,
+            },
+            tmp_path / f"settings-{len(remotes)}.json",
         )
-        assert diff_pixels == 0
+        remotes.append(remote)
+        return remote
 
-    return compare
+    yield _launch_server
+
+    for remote in remotes:
+        remote.kill()
diff --git a/tests/golden-chromium/mask-should-work-with-element-handle.png b/tests/golden-chromium/mask-should-work-with-element-handle.png
new file mode 100644
index 000000000..5a13aac48
Binary files /dev/null and b/tests/golden-chromium/mask-should-work-with-element-handle.png differ
diff --git a/tests/golden-chromium/mask-should-work-with-locator.png b/tests/golden-chromium/mask-should-work-with-locator.png
new file mode 100644
index 000000000..5a13aac48
Binary files /dev/null and b/tests/golden-chromium/mask-should-work-with-locator.png differ
diff --git a/tests/golden-chromium/mask-should-work-with-page.png b/tests/golden-chromium/mask-should-work-with-page.png
new file mode 100644
index 000000000..c663e342d
Binary files /dev/null and b/tests/golden-chromium/mask-should-work-with-page.png differ
diff --git a/tests/golden-chromium/screenshot-element-bounding-box.png b/tests/golden-chromium/screenshot-element-bounding-box.png
new file mode 100644
index 000000000..c2c3ddca2
Binary files /dev/null and b/tests/golden-chromium/screenshot-element-bounding-box.png differ
diff --git a/tests/golden-firefox/mask-should-work-with-element-handle.png b/tests/golden-firefox/mask-should-work-with-element-handle.png
new file mode 100644
index 000000000..682da85e8
Binary files /dev/null and b/tests/golden-firefox/mask-should-work-with-element-handle.png differ
diff --git a/tests/golden-firefox/mask-should-work-with-locator.png b/tests/golden-firefox/mask-should-work-with-locator.png
new file mode 100644
index 000000000..682da85e8
Binary files /dev/null and b/tests/golden-firefox/mask-should-work-with-locator.png differ
diff --git a/tests/golden-firefox/mask-should-work-with-page.png b/tests/golden-firefox/mask-should-work-with-page.png
new file mode 100644
index 000000000..720828ebf
Binary files /dev/null and b/tests/golden-firefox/mask-should-work-with-page.png differ
diff --git a/tests/golden-firefox/screenshot-element-bounding-box.png b/tests/golden-firefox/screenshot-element-bounding-box.png
new file mode 100644
index 000000000..9e208f86d
Binary files /dev/null and b/tests/golden-firefox/screenshot-element-bounding-box.png differ
diff --git a/tests/golden-webkit/mask-should-work-with-element-handle.png b/tests/golden-webkit/mask-should-work-with-element-handle.png
new file mode 100644
index 000000000..f31b468ff
Binary files /dev/null and b/tests/golden-webkit/mask-should-work-with-element-handle.png differ
diff --git a/tests/golden-webkit/mask-should-work-with-locator.png b/tests/golden-webkit/mask-should-work-with-locator.png
new file mode 100644
index 000000000..f31b468ff
Binary files /dev/null and b/tests/golden-webkit/mask-should-work-with-locator.png differ
diff --git a/tests/golden-webkit/mask-should-work-with-page.png b/tests/golden-webkit/mask-should-work-with-page.png
new file mode 100644
index 000000000..419417be4
Binary files /dev/null and b/tests/golden-webkit/mask-should-work-with-page.png differ
diff --git a/tests/golden-webkit/screenshot-element-bounding-box.png b/tests/golden-webkit/screenshot-element-bounding-box.png
new file mode 100644
index 000000000..1f74a3baf
Binary files /dev/null and b/tests/golden-webkit/screenshot-element-bounding-box.png differ
diff --git a/tests/server.py b/tests/server.py
index f37a80383..d69176950 100644
--- a/tests/server.py
+++ b/tests/server.py
@@ -14,35 +14,156 @@
 
 import abc
 import asyncio
+import contextlib
 import gzip
 import mimetypes
+import pathlib
 import socket
 import threading
 from contextlib import closing
 from http import HTTPStatus
-
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    Generic,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    TypeVar,
+    Union,
+    cast,
+)
+from urllib.parse import urlparse
+
+from autobahn.twisted.resource import WebSocketResource
 from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol
 from OpenSSL import crypto
-from twisted.internet import reactor, ssl
+from pyee import EventEmitter
+from twisted.internet import reactor as _twisted_reactor
+from twisted.internet import ssl
+from twisted.internet.selectreactor import SelectReactor
 from twisted.web import http
 
 from playwright._impl._path_utils import get_file_dirname
 
 _dirname = get_file_dirname()
+reactor = cast(SelectReactor, _twisted_reactor)
 
 
-def _find_free_port():
+def find_free_port() -> int:
     with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
         s.bind(("", 0))
         s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         return s.getsockname()[1]
 
 
+T = TypeVar("T")
+
+
+class ExpectResponse(Generic[T]):
+    def __init__(self) -> None:
+        self._value: T
+
+    @property
+    def value(self) -> T:
+        if not hasattr(self, "_value"):
+            raise ValueError("no received value")
+        return self._value
+
+
+class TestServerRequest(http.Request):
+    __test__ = False
+    channel: "TestServerHTTPChannel"
+    post_body: Optional[bytes] = None
+
+    def process(self) -> None:
+        server = self.channel.factory.server_instance
+        if self.content:
+            self.post_body = self.content.read()
+            self.content.seek(0, 0)
+        else:
+            self.post_body = None
+        path = urlparse(self.uri.decode()).path
+
+        request_subscriber = server.request_subscribers.get(path)
+        if request_subscriber:
+            request_subscriber._loop.call_soon_threadsafe(
+                request_subscriber.set_result, self
+            )
+            server.request_subscribers.pop(path)
+
+        if path == "/ws":
+            server._ws_resource.render(self)
+            return
+
+        if server.auth.get(path):
+            authorization_header = self.requestHeaders.getRawHeaders("authorization")
+            creds_correct = False
+            if authorization_header:
+                creds_correct = server.auth.get(path) == (
+                    self.getUser().decode(),
+                    self.getPassword().decode(),
+                )
+            if not creds_correct:
+                self.setHeader(b"www-authenticate", 'Basic realm="Secure Area"')
+                self.setResponseCode(HTTPStatus.UNAUTHORIZED)
+                self.write(b"HTTP Error 401 Unauthorized: Access is denied")
+                self.finish()
+                return
+        if server.csp.get(path):
+            self.setHeader(b"Content-Security-Policy", server.csp[path])
+        if server.routes.get(path):
+            server.routes[path](self)
+            return
+
+        self._serve_file(server.static_path / path[1:], path)
+
+    def serve_file(self, path: pathlib.Path) -> None:
+        return self._serve_file(path, urlparse(self.uri.decode()).path)
+
+    def _serve_file(self, path: pathlib.Path, request_path: str) -> None:
+        server = self.channel.factory.server_instance
+        file_content = None
+        try:
+            file_content = path.read_bytes()
+            content_type = mimetypes.guess_type(path)[0]
+            if content_type and content_type.startswith("text/"):
+                content_type += "; charset=utf-8"
+            self.setHeader(b"Content-Type", content_type)
+            self.setHeader(b"Cache-Control", "no-cache, no-store")
+            if request_path in server.gzip_routes:
+                self.setHeader("Content-Encoding", "gzip")
+                self.write(gzip.compress(file_content))
+            else:
+                self.setHeader(b"Content-Length", str(len(file_content)))
+                self.write(file_content)
+            self.setResponseCode(HTTPStatus.OK)
+        except (FileNotFoundError, IsADirectoryError, PermissionError):
+            self.setHeader(b"Content-Type", "text/plain")
+            self.setResponseCode(HTTPStatus.NOT_FOUND)
+            if self.method != "HEAD":
+                self.write(f"File not found: {path}".encode())
+        self.finish()
+
+
+class TestServerHTTPChannel(http.HTTPChannel):
+    factory: "TestServerFactory"
+    requestFactory = TestServerRequest
+
+
+class TestServerFactory(http.HTTPFactory):
+    server_instance: "Server"
+    protocol = TestServerHTTPChannel
+
+
 class Server:
     protocol = "http"
 
-    def __init__(self):
-        self.PORT = _find_free_port()
+    def __init__(self) -> None:
+        self.PORT = find_free_port()
         self.EMPTY_PAGE = f"{self.protocol}://localhost:{self.PORT}/empty.html"
         self.PREFIX = f"{self.protocol}://localhost:{self.PORT}"
         self.CROSS_PROCESS_PREFIX = f"{self.protocol}://127.0.0.1:{self.PORT}"
@@ -57,123 +178,141 @@ def __repr__(self) -> str:
         return self.PREFIX
 
     @abc.abstractmethod
-    def listen(self, factory):
+    def listen(self, factory: TestServerFactory) -> None:
         pass
 
-    def start(self):
-        request_subscribers = {}
-        auth = {}
-        csp = {}
-        routes = {}
-        gzip_routes = set()
+    def start(self, static_path: pathlib.Path = _dirname / "assets") -> None:
+        request_subscribers: Dict[str, asyncio.Future] = {}
+        auth: Dict[str, Tuple[str, str]] = {}
+        csp: Dict[str, str] = {}
+        routes: Dict[str, Callable[[TestServerRequest], Any]] = {}
+        gzip_routes: Set[str] = set()
         self.request_subscribers = request_subscribers
         self.auth = auth
         self.csp = csp
         self.routes = routes
+        self._ws_handlers: List[Callable[["WebSocketProtocol"], None]] = []
         self.gzip_routes = gzip_routes
-        static_path = _dirname / "assets"
-
-        class TestServerHTTPHandler(http.Request):
-            def process(self):
-                request = self
-                self.post_body = request.content.read()
-                request.content.seek(0, 0)
-                uri = request.uri.decode()
-                if request_subscribers.get(uri):
-                    request_subscribers[uri].set_result(request)
-                    request_subscribers.pop(uri)
-
-                if auth.get(uri):
-                    authorization_header = request.requestHeaders.getRawHeaders(
-                        "authorization"
-                    )
-                    creds_correct = False
-                    if authorization_header:
-                        creds_correct = auth.get(uri) == (
-                            request.getUser(),
-                            request.getPassword(),
-                        )
-                    if not creds_correct:
-                        request.setHeader(
-                            b"www-authenticate", 'Basic realm="Secure Area"'
-                        )
-                        request.setResponseCode(HTTPStatus.UNAUTHORIZED)
-                        request.finish()
-                        return
-                if csp.get(uri):
-                    request.setHeader(b"Content-Security-Policy", csp[uri])
-                if routes.get(uri):
-                    routes[uri](request)
-                    return
-                file_content = None
-                try:
-                    file_content = (
-                        static_path / request.path.decode()[1:]
-                    ).read_bytes()
-                    request.setHeader(b"Content-Type", mimetypes.guess_type(uri)[0])
-                    request.setHeader(b"Cache-Control", "no-cache, no-store")
-                    if uri in gzip_routes:
-                        request.setHeader("Content-Encoding", "gzip")
-                        request.write(gzip.compress(file_content))
-                    else:
-                        request.write(file_content)
-                    self.setResponseCode(HTTPStatus.OK)
-                except (FileNotFoundError, IsADirectoryError):
-                    request.setResponseCode(HTTPStatus.NOT_FOUND)
-                self.finish()
+        self.static_path = static_path
+        factory = TestServerFactory()
+        factory.server_instance = self
 
-        class MyHttp(http.HTTPChannel):
-            requestFactory = TestServerHTTPHandler
+        ws_factory = WebSocketServerFactory()
+        ws_factory.protocol = WebSocketProtocol
+        setattr(ws_factory, "server_instance", self)
+        self._ws_resource = WebSocketResource(ws_factory)
 
-        class MyHttpFactory(http.HTTPFactory):
-            protocol = MyHttp
+        self.listen(factory)
 
-        self.listen(MyHttpFactory())
-
-    async def wait_for_request(self, path):
+    async def wait_for_request(self, path: str) -> TestServerRequest:
         if path in self.request_subscribers:
             return await self.request_subscribers[path]
-        future = asyncio.Future()
+        future: asyncio.Future["TestServerRequest"] = asyncio.Future()
         self.request_subscribers[path] = future
         return await future
 
-    def set_auth(self, path: str, username: str, password: str):
+    def wait_for_web_socket(self) -> 'asyncio.Future["WebSocketProtocol"]':
+        future: asyncio.Future[WebSocketProtocol] = asyncio.Future()
+        self.once_web_socket_connection(future.set_result)
+        return future
+
+    @contextlib.contextmanager
+    def expect_request(
+        self, path: str
+    ) -> Generator[ExpectResponse[TestServerRequest], None, None]:
+        future = asyncio.create_task(self.wait_for_request(path))
+
+        cb_wrapper: ExpectResponse[TestServerRequest] = ExpectResponse()
+
+        def done_cb(task: asyncio.Task) -> None:
+            cb_wrapper._value = future.result()
+
+        future.add_done_callback(done_cb)
+        yield cb_wrapper
+
+    @contextlib.contextmanager
+    def expect_websocket(
+        self,
+    ) -> Generator[ExpectResponse["WebSocketProtocol"], None, None]:
+        future = self.wait_for_web_socket()
+
+        cb_wrapper: ExpectResponse["WebSocketProtocol"] = ExpectResponse()
+
+        def done_cb(_: asyncio.Future) -> None:
+            cb_wrapper._value = future.result()
+
+        future.add_done_callback(done_cb)
+        yield cb_wrapper
+
+    def set_auth(self, path: str, username: str, password: str) -> None:
         self.auth[path] = (username, password)
 
-    def set_csp(self, path: str, value: str):
+    def set_csp(self, path: str, value: str) -> None:
         self.csp[path] = value
 
-    def reset(self):
+    def reset(self) -> None:
         self.request_subscribers.clear()
         self.auth.clear()
         self.csp.clear()
         self.gzip_routes.clear()
         self.routes.clear()
+        self._ws_handlers.clear()
 
-    def set_route(self, path, callback):
+    def set_route(
+        self, path: str, callback: Callable[[TestServerRequest], Any]
+    ) -> None:
         self.routes[path] = callback
 
-    def enable_gzip(self, path):
+    def enable_gzip(self, path: str) -> None:
         self.gzip_routes.add(path)
 
-    def set_redirect(self, from_, to):
-        def handle_redirect(request):
+    def set_redirect(self, from_: str, to: str) -> None:
+        def handle_redirect(request: http.Request) -> None:
             request.setResponseCode(HTTPStatus.FOUND)
             request.setHeader("location", to)
             request.finish()
 
         self.set_route(from_, handle_redirect)
 
+    def send_on_web_socket_connection(self, data: bytes) -> None:
+        self.once_web_socket_connection(lambda ws: ws.sendMessage(data))
+
+    def once_web_socket_connection(
+        self, handler: Callable[["WebSocketProtocol"], None]
+    ) -> None:
+        self._ws_handlers.append(handler)
+
 
 class HTTPServer(Server):
-    def listen(self, factory):
-        reactor.listenTCP(self.PORT, factory)
+    def __init__(self) -> None:
+        self._listeners: list[Any] = []
+        super().__init__()
+
+    def listen(self, factory: http.HTTPFactory) -> None:
+        self._listeners.append(
+            reactor.listenTCP(self.PORT, factory, interface="127.0.0.1")
+        )
+        try:
+            self._listeners.append(
+                reactor.listenTCP(self.PORT, factory, interface="::1")
+            )
+        except Exception:
+            pass
+
+    def stop(self) -> None:
+        for listener in self._listeners:
+            listener.stopListening()
+        self._listeners.clear()
 
 
 class HTTPSServer(Server):
     protocol = "https"
 
-    def listen(self, factory):
+    def __init__(self) -> None:
+        self._listeners: list[Any] = []
+        super().__init__()
+
+    def listen(self, factory: http.HTTPFactory) -> None:
         cert = ssl.PrivateCertificate.fromCertificateAndKeyPair(
             ssl.Certificate.loadPEM(
                 (_dirname / "testserver" / "cert.pem").read_bytes()
@@ -183,53 +322,54 @@ def listen(self, factory):
             ),
         )
         contextFactory = cert.options()
-        reactor.listenSSL(self.PORT, factory, contextFactory)
-
-
-class WebSocketServerServer(WebSocketServerProtocol):
-    def __init__(self) -> None:
-        super().__init__()
-        self.PORT = _find_free_port()
+        self._listeners.append(
+            reactor.listenSSL(self.PORT, factory, contextFactory, interface="127.0.0.1")
+        )
+        try:
+            self._listeners.append(
+                reactor.listenSSL(self.PORT, factory, contextFactory, interface="::1")
+            )
+        except Exception:
+            pass
 
-    def start(self):
-        ws = WebSocketServerFactory("ws://127.0.0.1:" + str(self.PORT))
-        ws.protocol = WebSocketProtocol
-        reactor.listenTCP(self.PORT, ws)
+    def stop(self) -> None:
+        for listener in self._listeners:
+            listener.stopListening()
+        self._listeners.clear()
 
 
 class WebSocketProtocol(WebSocketServerProtocol):
-    def onConnect(self, request):
-        pass
-
-    def onOpen(self):
-        self.sendMessage(b"incoming")
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.events = EventEmitter()
+
+    def onClose(self, wasClean: bool, code: int, reason: str) -> None:
+        super().onClose(wasClean, code, reason)
+        self.events.emit(
+            "close",
+            code,
+            reason,
+        )
 
-    def onMessage(self, payload, isBinary):
-        if payload == b"echo-bin":
-            self.sendMessage(b"\x04\x02", True)
-            self.sendClose()
-        if payload == b"echo-text":
-            self.sendMessage(b"text", False)
-            self.sendClose()
-        if payload == b"close":
-            self.sendClose()
+    def onMessage(self, payload: Union[str, bytes], isBinary: bool) -> None:
+        self.events.emit("message", payload, isBinary)
 
-    def onClose(self, wasClean, code, reason):
-        pass
+    def onOpen(self) -> None:
+        for handler in getattr(self.factory, "server_instance")._ws_handlers.copy():
+            getattr(self.factory, "server_instance")._ws_handlers.remove(handler)
+            handler(self)
 
 
 class TestServer:
     def __init__(self) -> None:
         self.server = HTTPServer()
         self.https_server = HTTPSServer()
-        self.ws_server = WebSocketServerServer()
 
     def start(self) -> None:
         self.server.start()
         self.https_server.start()
-        self.ws_server.start()
         self.thread = threading.Thread(
-            target=lambda: reactor.run(installSignalHandlers=0)
+            target=lambda: reactor.run(installSignalHandlers=False)
         )
         self.thread.start()
 
diff --git a/tests/sync/conftest.py b/tests/sync/conftest.py
index db668f52a..2a6e365cb 100644
--- a/tests/sync/conftest.py
+++ b/tests/sync/conftest.py
@@ -1,6 +1,6 @@
 # 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
 #
@@ -13,19 +13,47 @@
 # limitations under the License.
 
 
+import asyncio
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Callable, Dict, Generator, List
+
 import pytest
+from greenlet import greenlet
+
+from playwright._impl._driver import compute_driver_executable
+from playwright.sync_api import (
+    Browser,
+    BrowserContext,
+    BrowserType,
+    FrameLocator,
+    Locator,
+    Page,
+    Playwright,
+    Selectors,
+    sync_playwright,
+)
+from tests.server import HTTPServer
+
+from .utils import Utils
+from .utils import utils as utils_object
 
-from playwright.sync_api import sync_playwright
+
+@pytest.fixture
+def utils() -> Generator[Utils, None, None]:
+    yield utils_object
 
 
 @pytest.fixture(scope="session")
-def playwright():
+def playwright() -> Generator[Playwright, None, None]:
     with sync_playwright() as p:
         yield p
 
 
 @pytest.fixture(scope="session")
-def browser_type(playwright, browser_name):
+def browser_type(
+    playwright: Playwright, browser_name: str
+) -> Generator[BrowserType, None, None]:
     browser_type = None
     if browser_name == "chromium":
         browser_type = playwright.chromium
@@ -33,25 +61,139 @@ def browser_type(playwright, browser_name):
         browser_type = playwright.firefox
     elif browser_name == "webkit":
         browser_type = playwright.webkit
+    assert browser_type, f"Unkown browser name '{browser_name}'"
     yield browser_type
 
 
 @pytest.fixture(scope="session")
-def browser(browser_type, launch_arguments):
+def browser(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> Generator[Browser, None, None]:
     browser = browser_type.launch(**launch_arguments)
     yield browser
     browser.close()
 
 
 @pytest.fixture
-def context(browser):
+def context(browser: Browser) -> Generator[BrowserContext, None, None]:
     context = browser.new_context()
     yield context
     context.close()
 
 
 @pytest.fixture
-def page(context):
+def page(context: BrowserContext) -> Generator[Page, None, None]:
     page = context.new_page()
     yield page
     page.close()
+
+
+@pytest.fixture(scope="session")
+def selectors(playwright: Playwright) -> Selectors:
+    return playwright.selectors
+
+
+@pytest.fixture(scope="session")
+def sync_gather(playwright: Playwright) -> Generator[Callable, None, None]:
+    def _sync_gather_impl(*actions: Callable) -> List[Any]:
+        g_self = greenlet.getcurrent()
+        results: Dict[Callable, Any] = {}
+        exceptions: List[Exception] = []
+
+        def action_wrapper(action: Callable) -> Callable:
+            def body() -> Any:
+                try:
+                    results[action] = action()
+                except Exception as e:
+                    results[action] = e
+                    exceptions.append(e)
+                g_self.switch()
+
+            return body
+
+        async def task() -> None:
+            for action in actions:
+                g = greenlet(action_wrapper(action))
+                g.switch()
+
+        asyncio.create_task(task())
+
+        while len(results) < len(actions):
+            playwright._dispatcher_fiber.switch()
+
+        if exceptions:
+            raise exceptions[0]
+
+        return list(map(lambda action: results[action], actions))
+
+    yield _sync_gather_impl
+
+
+class TraceViewerPage:
+    def __init__(self, page: Page):
+        self.page = page
+
+    @property
+    def actions_tree(self) -> Locator:
+        return self.page.get_by_test_id("actions-tree")
+
+    @property
+    def action_titles(self) -> Locator:
+        return self.page.locator(".action-title")
+
+    @property
+    def stack_frames(self) -> Locator:
+        return self.page.get_by_role("listbox", name="Stack trace").get_by_role(
+            "option"
+        )
+
+    def select_action(self, title: str, ordinal: int = 0) -> None:
+        self.page.locator(".action-title", has_text=title).nth(ordinal).click()
+
+    def select_snapshot(self, name: str) -> None:
+        self.page.click(f'.snapshot-tab .tabbed-pane-tab-label:has-text("{name}")')
+
+    def snapshot_frame(
+        self, action_name: str, ordinal: int = 0, has_subframe: bool = False
+    ) -> FrameLocator:
+        self.select_action(action_name, ordinal)
+        expected_frames = 4 if has_subframe else 3
+        while len(self.page.frames) < expected_frames:
+            self.page.wait_for_event("frameattached")
+        return self.page.frame_locator("iframe.snapshot-visible[name=snapshot]")
+
+    def show_source_tab(self) -> None:
+        self.page.click("text='Source'")
+
+    def expand_action(self, title: str, ordinal: int = 0) -> None:
+        self.actions_tree.locator(".tree-view-entry", has_text=title).nth(
+            ordinal
+        ).locator(".codicon-chevron-right").click()
+
+
+@pytest.fixture
+def show_trace_viewer(browser: Browser) -> Generator[Callable, None, None]:
+    """Fixture that provides a function to show trace viewer for a trace file."""
+
+    @contextmanager
+    def _show_trace_viewer(
+        trace_path: Path,
+    ) -> Generator[TraceViewerPage, None, None]:
+        trace_viewer_path = (
+            Path(compute_driver_executable()[0]) / "../package/lib/vite/traceViewer"
+        ).resolve()
+
+        server = HTTPServer()
+        server.start(trace_viewer_path)
+        server.set_route("/trace.zip", lambda request: request.serve_file(trace_path))
+
+        page = browser.new_page()
+
+        try:
+            page.goto(f"{server.PREFIX}/index.html?trace={server.PREFIX}/trace.zip")
+            yield TraceViewerPage(page)
+        finally:
+            page.close()
+            server.stop()
+
+    yield _show_trace_viewer
diff --git a/tests/sync/test_accessibility.py b/tests/sync/test_accessibility.py
deleted file mode 100644
index bcd509deb..000000000
--- a/tests/sync/test_accessibility.py
+++ /dev/null
@@ -1,413 +0,0 @@
-# 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 pytest
-
-
-def test_accessibility_should_work(page, is_firefox, is_chromium):
-    page.set_content(
-        """<head>
-      <title>Accessibility Test</title>
-    </head>
-    <body>
-      <h1>Inputs</h1>
-      <input placeholder="Empty input" autofocus />
-      <input placeholder="readonly input" readonly />
-      <input placeholder="disabled input" disabled />
-      <input aria-label="Input with whitespace" value="  " />
-      <input value="value only" />
-      <input aria-placeholder="placeholder" value="and a value" />
-      <div aria-hidden="true" id="desc">This is a description!</div>
-      <input aria-placeholder="placeholder" value="and a value" aria-describedby="desc" />
-    </body>"""
-    )
-    # autofocus happens after a delay in chrome these days
-    page.wait_for_function("document.activeElement.hasAttribute('autofocus')")
-
-    if is_firefox:
-        golden = {
-            "role": "document",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {
-                    "role": "textbox",
-                    "name": "",
-                    "value": "and a value",
-                },  # firefox doesn't use aria-placeholder for the name
-                {
-                    "role": "textbox",
-                    "name": "",
-                    "value": "and a value",
-                    "description": "This is a description!",
-                },  # and here
-            ],
-        }
-    elif is_chromium:
-        golden = {
-            "role": "WebArea",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {"role": "textbox", "name": "placeholder", "value": "and a value"},
-                {
-                    "role": "textbox",
-                    "name": "placeholder",
-                    "value": "and a value",
-                    "description": "This is a description!",
-                },
-            ],
-        }
-    else:
-        golden = {
-            "role": "WebArea",
-            "name": "Accessibility Test",
-            "children": [
-                {"role": "heading", "name": "Inputs", "level": 1},
-                {"role": "textbox", "name": "Empty input", "focused": True},
-                {"role": "textbox", "name": "readonly input", "readonly": True},
-                {"role": "textbox", "name": "disabled input", "disabled": True},
-                {"role": "textbox", "name": "Input with whitespace", "value": "  "},
-                {"role": "textbox", "name": "", "value": "value only"},
-                {"role": "textbox", "name": "placeholder", "value": "and a value"},
-                {
-                    "role": "textbox",
-                    "name": "This is a description!",
-                    "value": "and a value",
-                },  # webkit uses the description over placeholder for the name
-            ],
-        }
-    assert page.accessibility.snapshot() == golden
-
-
-def test_accessibility_should_work_with_regular_text(page, is_firefox):
-    page.set_content("<div>Hello World</div>")
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0] == {
-        "role": "text leaf" if is_firefox else "text",
-        "name": "Hello World",
-    }
-
-
-def test_accessibility_roledescription(page):
-    page.set_content('<div tabIndex=-1 aria-roledescription="foo">Hi</div>')
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0]["roledescription"] == "foo"
-
-
-def test_accessibility_orientation(page):
-    page.set_content('<a href="" role="slider" aria-orientation="vertical">11</a>')
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0]["orientation"] == "vertical"
-
-
-def test_accessibility_autocomplete(page):
-    page.set_content('<div role="textbox" aria-autocomplete="list">hi</div>')
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0]["autocomplete"] == "list"
-
-
-def test_accessibility_multiselectable(page):
-    page.set_content('<div role="grid" tabIndex=-1 aria-multiselectable=true>hey</div>')
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0]["multiselectable"]
-
-
-def test_accessibility_keyshortcuts(page):
-    page.set_content('<div role="grid" tabIndex=-1 aria-keyshortcuts="foo">hey</div>')
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0]["keyshortcuts"] == "foo"
-
-
-def test_accessibility_filtering_children_of_leaf_nodes_should_not_report_text_nodes_inside_controls(
-    page, is_firefox
-):
-    page.set_content(
-        """
-    <div role="tablist">
-    <div role="tab" aria-selected="true"><b>Tab1</b></div>
-    <div role="tab">Tab2</div>
-    </div>"""
-    )
-    golden = {
-        "role": "document" if is_firefox else "WebArea",
-        "name": "",
-        "children": [
-            {"role": "tab", "name": "Tab1", "selected": True},
-            {"role": "tab", "name": "Tab2"},
-        ],
-    }
-    assert page.accessibility.snapshot() == golden
-
-
-# WebKit rich text accessibility is iffy
-@pytest.mark.skip_browser("webkit")
-def test_accessibility_filtering_children_of_leaf_nodes_rich_text_editable_fields_should_have_children(
-    page, is_firefox
-):
-    page.set_content(
-        """
-    <div contenteditable="true">
-    Edit this image: <img src="fakeimage.png" alt="my fake image">
-    </div>"""
-    )
-    golden = (
-        {
-            "role": "section",
-            "name": "",
-            "children": [
-                {"role": "text leaf", "name": "Edit this image: "},
-                {"role": "text", "name": "my fake image"},
-            ],
-        }
-        if is_firefox
-        else {
-            "role": "generic",
-            "name": "",
-            "value": "Edit this image: ",
-            "children": [
-                {"role": "text", "name": "Edit this image:"},
-                {"role": "img", "name": "my fake image"},
-            ],
-        }
-    )
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0] == golden
-
-
-# WebKit rich text accessibility is iffy
-@pytest.mark.skip_browser("webkit")
-def test_accessibility_filtering_children_of_leaf_nodes_rich_text_editable_fields_with_role_should_have_children(
-    page,
-    is_firefox,
-):
-    page.set_content(
-        """
-    <div contenteditable="true" role='textbox'>
-    Edit this image: <img src="fakeimage.png" alt="my fake image">
-    </div>"""
-    )
-    if is_firefox:
-        golden = {
-            "role": "textbox",
-            "name": "",
-            "value": "Edit this image: my fake image",
-            "children": [{"role": "text", "name": "my fake image"}],
-        }
-    else:
-        golden = {
-            "role": "textbox",
-            "name": "",
-            "value": "Edit this image: ",
-            "children": [
-                {"role": "text", "name": "Edit this image:"},
-                {"role": "img", "name": "my fake image"},
-            ],
-        }
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0] == golden
-
-
-# Firefox does not support contenteditable="plaintext-only".
-# WebKit rich text accessibility is iffy
-@pytest.mark.only_browser("chromium")
-def test_accessibility_plain_text_field_with_role_should_not_have_children(page):
-    page.set_content(
-        """
-    <div contenteditable="plaintext-only" role='textbox'>Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0] == {
-        "role": "textbox",
-        "name": "",
-        "value": "Edit this image:",
-    }
-
-
-@pytest.mark.only_browser("chromium")
-def test_accessibility_plain_text_field_without_role_should_not_have_content(
-    page,
-):
-    page.set_content(
-        """
-    <div contenteditable="plaintext-only">Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0] == {"role": "generic", "name": ""}
-
-
-@pytest.mark.only_browser("chromium")
-def test_accessibility_plain_text_field_with_tabindex_and_without_role_should_not_have_content(
-    page,
-):
-    page.set_content(
-        """
-    <div contenteditable="plaintext-only" tabIndex=0>Edit this image:<img src="fakeimage.png" alt="my fake image"></div>"""
-    )
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0] == {"role": "generic", "name": ""}
-
-
-def test_accessibility_non_editable_textbox_with_role_and_tabIndex_and_label_should_not_have_children(
-    page, is_chromium, is_firefox
-):
-    page.set_content(
-        """
-      <div role="textbox" tabIndex=0 aria-checked="true" aria-label="my favorite textbox">
-        this is the inner content
-        <img alt="yo" src="fakeimg.png">
-      </div>"""
-    )
-    if is_firefox:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content yo",
-        }
-    elif is_chromium:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content ",
-        }
-    else:
-        golden = {
-            "role": "textbox",
-            "name": "my favorite textbox",
-            "value": "this is the inner content  ",
-        }
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0] == golden
-
-
-def test_accessibility_checkbox_with_and_tabIndex_and_label_should_not_have_children(
-    page,
-):
-    page.set_content(
-        """
-    <div role="checkbox" tabIndex=0 aria-checked="true" aria-label="my favorite checkbox">
-    this is the inner content
-    <img alt="yo" src="fakeimg.png">
-    </div>"""
-    )
-    golden = {"role": "checkbox", "name": "my favorite checkbox", "checked": True}
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0] == golden
-
-
-def test_accessibility_checkbox_without_label_should_not_have_children(
-    page, is_firefox
-):
-    page.set_content(
-        """
-      <div role="checkbox" aria-checked="true">
-        this is the inner content
-        <img alt="yo" src="fakeimg.png">
-    </div>"""
-    )
-    golden = {
-        "role": "checkbox",
-        "name": "this is the inner content yo",
-        "checked": True,
-    }
-    snapshot = page.accessibility.snapshot()
-    assert snapshot["children"][0] == golden
-
-
-def test_accessibility_should_work_a_button(page):
-    page.set_content("<button>My Button</button>")
-
-    button = page.query_selector("button")
-    assert page.accessibility.snapshot(root=button) == {
-        "role": "button",
-        "name": "My Button",
-    }
-
-
-def test_accessibility_should_work_an_input(page):
-    page.set_content('<input title="My Input" value="My Value">')
-
-    input = page.query_selector("input")
-    assert page.accessibility.snapshot(root=input) == {
-        "role": "textbox",
-        "name": "My Input",
-        "value": "My Value",
-    }
-
-
-def test_accessibility_should_work_on_a_menu(page, is_webkit):
-    page.set_content(
-        """
-        <div role="menu" title="My Menu">
-        <div role="menuitem">First Item</div>
-        <div role="menuitem">Second Item</div>
-        <div role="menuitem">Third Item</div>
-        </div>
-    """
-    )
-
-    menu = page.query_selector('div[role="menu"]')
-    golden = {
-        "role": "menu",
-        "name": "My Menu",
-        "children": [
-            {"role": "menuitem", "name": "First Item"},
-            {"role": "menuitem", "name": "Second Item"},
-            {"role": "menuitem", "name": "Third Item"},
-        ],
-    }
-    if is_webkit:
-        golden["orientation"] = "vertical"
-    assert page.accessibility.snapshot(root=menu) == golden
-
-
-def test_accessibility_should_return_null_when_the_element_is_no_longer_in_DOM(
-    page,
-):
-    page.set_content("<button>My Button</button>")
-    button = page.query_selector("button")
-    page.eval_on_selector("button", "button => button.remove()")
-    assert page.accessibility.snapshot(root=button) is None
-
-
-def test_accessibility_should_show_uninteresting_nodes(page):
-    page.set_content(
-        """
-        <div id="root" role="textbox">
-        <div>
-            hello
-            <div>
-            world
-            </div>
-        </div>
-        </div>
-    """
-    )
-
-    root = page.query_selector("#root")
-    snapshot = page.accessibility.snapshot(root=root, interesting_only=False)
-    assert snapshot["role"] == "textbox"
-    assert "hello" in snapshot["value"]
-    assert "world" in snapshot["value"]
-    assert snapshot["children"]
diff --git a/tests/sync/test_add_init_script.py b/tests/sync/test_add_init_script.py
index 53fe4c8e5..cd508cf4d 100644
--- a/tests/sync/test_add_init_script.py
+++ b/tests/sync/test_add_init_script.py
@@ -1,6 +1,6 @@
 # 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
 #
@@ -12,37 +12,41 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from playwright.sync_api import Error, Page
+from pathlib import Path
 
+import pytest
 
-def test_add_init_script_evaluate_before_anything_else_on_the_page(page):
+from playwright.sync_api import BrowserContext, Error, Page
+
+
+def test_add_init_script_evaluate_before_anything_else_on_the_page(page: Page) -> None:
     page.add_init_script("window.injected = 123")
     page.goto("data:text/html,<script>window.result = window.injected</script>")
     assert page.evaluate("window.result") == 123
 
 
-def test_add_init_script_work_with_a_path(page, assetdir):
+def test_add_init_script_work_with_a_path(page: Page, assetdir: Path) -> None:
     page.add_init_script(path=assetdir / "injectedfile.js")
     page.goto("data:text/html,<script>window.result = window.injected</script>")
     assert page.evaluate("window.result") == 123
 
 
-def test_add_init_script_work_with_content(page: Page):
+def test_add_init_script_work_with_content(page: Page) -> None:
     page.add_init_script("window.injected = 123")
     page.goto("data:text/html,<script>window.result = window.injected</script>")
     assert page.evaluate("window.result") == 123
 
 
-def test_add_init_script_throw_without_path_and_content(page):
-    error = None
-    try:
-        page.add_init_script({"foo": "bar"})
-    except Error as e:
-        error = e
-    assert error.message == "Either path or source parameter must be specified"
+def test_add_init_script_throw_without_path_and_content(page: Page) -> None:
+    with pytest.raises(
+        Error, match="Either path or script parameter must be specified"
+    ):
+        page.add_init_script({"foo": "bar"})  # type: ignore
 
 
-def test_add_init_script_work_with_browser_context_scripts(page, context):
+def test_add_init_script_work_with_browser_context_scripts(
+    page: Page, context: BrowserContext
+) -> None:
     context.add_init_script("window.temp = 123")
     page = context.new_page()
     page.add_init_script("window.injected = window.temp")
@@ -51,8 +55,8 @@ def test_add_init_script_work_with_browser_context_scripts(page, context):
 
 
 def test_add_init_script_work_with_browser_context_scripts_with_a_path(
-    page, context, assetdir
-):
+    page: Page, context: BrowserContext, assetdir: Path
+) -> None:
     context.add_init_script(path=assetdir / "injectedfile.js")
     page = context.new_page()
     page.goto("data:text/html,<script>window.result = window.injected</script>")
@@ -60,17 +64,32 @@ def test_add_init_script_work_with_browser_context_scripts_with_a_path(
 
 
 def test_add_init_script_work_with_browser_context_scripts_for_already_created_pages(
-    page, context
-):
+    page: Page, context: BrowserContext
+) -> None:
     context.add_init_script("window.temp = 123")
     page.add_init_script("window.injected = window.temp")
     page.goto("data:text/html,<script>window.result = window.injected</script>")
     assert page.evaluate("window.result") == 123
 
 
-def test_add_init_script_support_multiple_scripts(page):
+def test_add_init_script_support_multiple_scripts(page: Page) -> None:
     page.add_init_script("window.script1 = 1")
     page.add_init_script("window.script2 = 2")
     page.goto("data:text/html,<script>window.result = window.injected</script>")
     assert page.evaluate("window.script1") == 1
     assert page.evaluate("window.script2") == 2
+
+
+def test_should_work_with_trailing_comments(page: Page) -> None:
+    page.add_init_script("// comment")
+    page.add_init_script("window.secret = 42;")
+    page.goto("data:text/html,<html></html>")
+    assert page.evaluate("secret") == 42
+
+
+def test_add_init_script_returns_disposable(page: Page) -> None:
+    with page.add_init_script("window.injected = 123"):
+        page.goto("data:text/html,<script>window.result = window.injected</script>")
+        assert page.evaluate("window.result") == 123
+    page.goto("data:text/html,<script>window.result = window.injected</script>")
+    assert page.evaluate("window.result") is None
diff --git a/tests/sync/test_assertions.py b/tests/sync/test_assertions.py
new file mode 100644
index 000000000..ed58cdcdd
--- /dev/null
+++ b/tests/sync/test_assertions.py
@@ -0,0 +1,1111 @@
+# 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 datetime
+import re
+
+import pytest
+
+from playwright.sync_api import Browser, Error, Page, expect
+from tests.server import Server
+
+
+def test_assertions_page_to_have_title(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<title>new title</title>")
+    expect(page).to_have_title("new title")
+    expect(page).to_have_title(re.compile("new title"))
+    with pytest.raises(AssertionError):
+        expect(page).to_have_title("not the current title", timeout=750)
+    with pytest.raises(AssertionError):
+        expect(page).to_have_title(re.compile("not the current title"), timeout=750)
+    with pytest.raises(AssertionError):
+        expect(page).not_to_have_title(re.compile("new title"), timeout=750)
+    with pytest.raises(AssertionError):
+        expect(page).not_to_have_title("new title", timeout=750)
+    expect(page).not_to_have_title("great title", timeout=750)
+    page.evaluate(
+        """
+        setTimeout(() => {
+            document.title = 'great title';
+        }, 2000);
+    """
+    )
+    expect(page).to_have_title("great title")
+    expect(page).to_have_title(re.compile("great title"))
+
+
+def test_assertions_page_to_have_url(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    expect(page).to_have_url(server.EMPTY_PAGE)
+    expect(page).to_have_url(re.compile(r".*/empty\.html"))
+    with pytest.raises(AssertionError):
+        expect(page).to_have_url("nooooo", timeout=750)
+    with pytest.raises(AssertionError):
+        expect(page).to_have_url(re.compile("not-the-url"), timeout=750)
+    page.evaluate(
+        """
+        setTimeout(() => {
+            window.location = window.location.origin + '/grid.html';
+        }, 2000);
+    """
+    )
+    expect(page).to_have_url(server.PREFIX + "/grid.html")
+    expect(page).not_to_have_url(server.EMPTY_PAGE, timeout=750)
+    with pytest.raises(AssertionError):
+        expect(page).not_to_have_url(re.compile(r".*/grid\.html"), timeout=750)
+    with pytest.raises(AssertionError):
+        expect(page).not_to_have_url(server.PREFIX + "/grid.html", timeout=750)
+    expect(page).to_have_url(re.compile(r".*/grid\.html"))
+    expect(page).not_to_have_url("**/empty.html", timeout=750)
+
+
+def test_assertions_page_to_have_url_with_base_url(
+    browser: Browser, server: Server
+) -> None:
+    page = browser.new_page(base_url=server.PREFIX)
+    page.goto("/empty.html")
+    expect(page).to_have_url("/empty.html")
+    expect(page).to_have_url(re.compile(r".*/empty\.html"))
+    page.close()
+
+
+def test_assertions_locator_to_contain_text(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div id=foobar>kek</div>")
+    expect(page.locator("div#foobar")).to_contain_text("kek")
+    expect(page.locator("div#foobar")).not_to_contain_text("bar", timeout=100)
+    with pytest.raises(AssertionError):
+        expect(page.locator("div#foobar")).to_contain_text("bar", timeout=100)
+
+    page.set_content("<div>Text \n1</div><div>Text2</div><div>Text3</div>")
+    expect(page.locator("div")).to_contain_text(["ext     1", re.compile("ext3")])
+
+
+def test_assertions_locator_to_have_attribute(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div id=foobar>kek</div>")
+    expect(page.locator("div#foobar")).to_have_attribute("id", "foobar")
+    expect(page.locator("div#foobar")).to_have_attribute("id", re.compile("foobar"))
+    expect(page.locator("div#foobar")).not_to_have_attribute("id", "kek", timeout=100)
+    with pytest.raises(AssertionError):
+        expect(page.locator("div#foobar")).to_have_attribute("id", "koko", timeout=100)
+
+
+def test_assertions_locator_to_have_attribute_ignore_case(
+    page: Page, server: Page
+) -> None:
+    page.set_content("<div id=NoDe>Text content</div>")
+    locator = page.locator("#NoDe")
+    expect(locator).to_have_attribute("id", "node", ignore_case=True)
+    expect(locator).not_to_have_attribute("id", "node")
+
+
+def test_assertions_locator_to_have_class(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div class=foobar>kek</div>")
+    expect(page.locator("div.foobar")).to_have_class("foobar")
+    expect(page.locator("div.foobar")).to_have_class(["foobar"])
+    expect(page.locator("div.foobar")).to_have_class(re.compile("foobar"))
+    expect(page.locator("div.foobar")).to_have_class([re.compile("foobar")])
+    expect(page.locator("div.foobar")).not_to_have_class("kekstar", timeout=100)
+    with pytest.raises(AssertionError):
+        expect(page.locator("div.foobar")).to_have_class("oh-no", timeout=100)
+
+
+def test_assertions_locator_to_contain_class(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div class='foo bar baz'></div>")
+    locator = page.locator("div")
+    expect(locator).to_contain_class("")
+    expect(locator).to_contain_class("bar")
+    expect(locator).to_contain_class("baz bar")
+    expect(locator).to_contain_class("  bar   foo ")
+    expect(locator).not_to_contain_class(
+        "  baz   not-matching "
+    )  # Strip whitespace and match individual classes
+    with pytest.raises(AssertionError) as excinfo:
+        expect(locator).to_contain_class("does-not-exist", timeout=100)
+
+    assert excinfo.match("Locator expected to contain class 'does-not-exist'")
+    assert excinfo.match("Actual value: foo bar baz")
+    assert excinfo.match('Expect "to_contain_class" with timeout 100ms')
+
+    page.set_content(
+        '<div class="foo"></div><div class="hello bar"></div><div class="baz"></div>'
+    )
+    expect(locator).to_contain_class(["foo", "hello", "baz"])
+    expect(locator).not_to_contain_class(["not-there", "hello", "baz"])
+    expect(locator).not_to_contain_class(["foo", "hello"])
+
+
+def test_assertions_locator_to_have_count(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div class=foobar>kek</div><div class=foobar>kek</div>")
+    expect(page.locator("div.foobar")).to_have_count(2)
+    expect(page.locator("div.foobar")).not_to_have_count(42, timeout=100)
+    with pytest.raises(AssertionError):
+        expect(page.locator("div.foobar")).to_have_count(42, timeout=100)
+
+
+def test_assertions_locator_to_have_css(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div class=foobar style='color: rgb(234, 74, 90);'>kek</div>")
+    expect(page.locator("div.foobar")).to_have_css("color", "rgb(234, 74, 90)")
+    expect(page.locator("div.foobar")).not_to_have_css(
+        "color", "rgb(42, 42, 42)", timeout=100
+    )
+    with pytest.raises(AssertionError):
+        expect(page.locator("div.foobar")).to_have_css(
+            "color", "rgb(42, 42, 42)", timeout=100
+        )
+
+
+def test_assertions_locator_to_have_id(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div class=foobar id=kek>kek</div>")
+    expect(page.locator("div.foobar")).to_have_id("kek")
+    expect(page.locator("div.foobar")).not_to_have_id("top", timeout=100)
+    with pytest.raises(AssertionError):
+        expect(page.locator("div.foobar")).to_have_id("top", timeout=100)
+
+
+def test_assertions_locator_to_have_js_property(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div></div>")
+    page.eval_on_selector(
+        "div", "e => e.foo = { a: 1, b: 'string', c: new Date(1627503992000) }"
+    )
+    expect(page.locator("div")).to_have_js_property(
+        "foo",
+        {
+            "a": 1,
+            "b": "string",
+            "c": datetime.datetime.fromtimestamp(1627503992000 / 1000),
+        },
+    )
+
+
+def test_to_have_js_property_pass_string(page: Page) -> None:
+    page.set_content("<div></div>")
+    page.eval_on_selector("div", "e => e.foo = 'string'")
+    locator = page.locator("div")
+    expect(locator).to_have_js_property("foo", "string")
+
+
+def test_to_have_js_property_fail_string(page: Page) -> None:
+    page.set_content("<div></div>")
+    page.eval_on_selector("div", "e => e.foo = 'string'")
+    locator = page.locator("div")
+    with pytest.raises(AssertionError):
+        expect(locator).to_have_js_property("foo", "error", timeout=500)
+
+
+def test_to_have_js_property_pass_number(page: Page) -> None:
+    page.set_content("<div></div>")
+    page.eval_on_selector("div", "e => e.foo = 2021")
+    locator = page.locator("div")
+    expect(locator).to_have_js_property("foo", 2021)
+
+
+def test_to_have_js_property_fail_number(page: Page) -> None:
+    page.set_content("<div></div>")
+    page.eval_on_selector("div", "e => e.foo = 2021")
+    locator = page.locator("div")
+    with pytest.raises(AssertionError):
+        expect(locator).to_have_js_property("foo", 1, timeout=500)
+
+
+def test_to_have_js_property_pass_boolean(page: Page) -> None:
+    page.set_content("<div></div>")
+    page.eval_on_selector("div", "e => e.foo = true")
+    locator = page.locator("div")
+    expect(locator).to_have_js_property("foo", True)
+
+
+def test_to_have_js_property_fail_boolean(page: Page) -> None:
+    page.set_content("<div></div>")
+    page.eval_on_selector("div", "e => e.foo = false")
+    locator = page.locator("div")
+    with pytest.raises(AssertionError):
+        expect(locator).to_have_js_property("foo", True, timeout=500)
+
+
+def test_to_have_js_property_pass_boolean_2(page: Page) -> None:
+    page.set_content("<div></div>")
+    page.eval_on_selector("div", "e => e.foo = false")
+    locator = page.locator("div")
+    expect(locator).to_have_js_property("foo", False)
+
+
+def test_to_have_js_property_fail_boolean_2(page: Page) -> None:
+    page.set_content("<div></div>")
+    page.eval_on_selector("div", "e => e.foo = false")
+    locator = page.locator("div")
+    with pytest.raises(AssertionError):
+        expect(locator).to_have_js_property("foo", True, timeout=500)
+
+
+def test_to_have_js_property_pass_null(page: Page) -> None:
+    page.set_content("<div></div>")
+    page.eval_on_selector("div", "e => e.foo = null")
+    locator = page.locator("div")
+    expect(locator).to_have_js_property("foo", None)
+
+
+def test_assertions_locator_to_have_text(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div id=foobar>kek</div>")
+    expect(page.locator("div#foobar")).to_have_text("kek")
+    expect(page.locator("div#foobar")).not_to_have_text("top", timeout=100)
+
+    page.set_content("<div>Text    \n1</div><div>Text   2a</div>")
+    # Should only normalize whitespace in the first item.
+    expect(page.locator("div")).to_have_text(["Text  1", re.compile(r"Text   \d+a")])
+
+
+@pytest.mark.parametrize(
+    "method",
+    ["to_have_text", "to_contain_text"],
+)
+def test_ignore_case(page: Page, server: Server, method: str) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div id=target>apple BANANA</div><div>orange</div>")
+    getattr(expect(page.locator("div#target")), method)("apple BANANA")
+    getattr(expect(page.locator("div#target")), method)(
+        "apple banana", ignore_case=True
+    )
+    # defaults false
+    with pytest.raises(AssertionError) as excinfo:
+        getattr(expect(page.locator("div#target")), method)(
+            "apple banana",
+            timeout=300,
+        )
+    expected_error_msg = method.replace("_", " ")
+    assert expected_error_msg in str(excinfo.value)
+
+    # Array Variants
+    getattr(expect(page.locator("div")), method)(["apple BANANA", "orange"])
+    getattr(expect(page.locator("div")), method)(
+        ["apple banana", "ORANGE"], ignore_case=True
+    )
+    # defaults false
+    with pytest.raises(AssertionError) as excinfo:
+        getattr(expect(page.locator("div")), method)(
+            ["apple banana", "ORANGE"],
+            timeout=300,
+        )
+    assert expected_error_msg in str(excinfo.value)
+
+    # not variant
+    getattr(expect(page.locator("div#target")), f"not_{method}")("apple banana")
+    with pytest.raises(AssertionError) as excinfo:
+        getattr(expect(page.locator("div#target")), f"not_{method}")(
+            "apple banana",
+            ignore_case=True,
+            timeout=300,
+        )
+    assert f"not {expected_error_msg}" in str(excinfo)
+
+
+@pytest.mark.parametrize(
+    "method",
+    ["to_have_text", "to_contain_text"],
+)
+def test_ignore_case_regex(page: Page, server: Server, method: str) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div id=target>apple BANANA</div><div>orange</div>")
+    getattr(expect(page.locator("div#target")), method)(re.compile("apple BANANA"))
+    getattr(expect(page.locator("div#target")), method)(
+        re.compile("apple banana"), ignore_case=True
+    )
+    # defaults to regex flag
+    with pytest.raises(AssertionError) as excinfo:
+        getattr(expect(page.locator("div#target")), method)(
+            re.compile("apple banana"), timeout=300
+        )
+    expected_error_msg = method.replace("_", " ")
+    assert expected_error_msg in str(excinfo.value)
+    # overrides regex flag
+    with pytest.raises(AssertionError) as excinfo:
+        getattr(expect(page.locator("div#target")), method)(
+            re.compile("apple banana", re.IGNORECASE),
+            ignore_case=False,
+            timeout=300,
+        )
+    assert expected_error_msg in str(excinfo.value)
+
+    # Array Variants
+    getattr(expect(page.locator("div")), method)(
+        [re.compile("apple BANANA"), re.compile("orange")]
+    )
+    getattr(expect(page.locator("div")), method)(
+        [re.compile("apple banana"), re.compile("ORANGE")], ignore_case=True
+    )
+    # defaults regex flag
+    with pytest.raises(AssertionError) as excinfo:
+        getattr(expect(page.locator("div")), method)(
+            [re.compile("apple banana"), re.compile("ORANGE")],
+            timeout=300,
+        )
+    assert expected_error_msg in str(excinfo.value)
+    # overrides regex flag
+    with pytest.raises(AssertionError) as excinfo:
+        getattr(expect(page.locator("div")), method)(
+            [
+                re.compile("apple banana", re.IGNORECASE),
+                re.compile("ORANGE", re.IGNORECASE),
+            ],
+            ignore_case=False,
+            timeout=300,
+        )
+    assert expected_error_msg in str(excinfo.value)
+
+    # not variant
+    getattr(expect(page.locator("div#target")), f"not_{method}")(
+        re.compile("apple banana")
+    )
+    with pytest.raises(AssertionError) as excinfo:
+        getattr(expect(page.locator("div#target")), f"not_{method}")(
+            re.compile("apple banana"),
+            ignore_case=True,
+            timeout=300,
+        )
+    assert f"not {expected_error_msg}" in str(excinfo)
+
+
+def test_assertions_locator_to_have_value(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<input type=text id=foo>")
+    my_input = page.locator("#foo")
+    expect(my_input).to_have_value("")
+    expect(my_input).not_to_have_value("bar", timeout=100)
+    my_input.fill("kektus")
+    expect(my_input).to_have_value("kektus")
+
+
+def test_to_have_values_works_with_text(page: Page, server: Server) -> None:
+    page.set_content(
+        """
+        <select multiple>
+            <option value="R">Red</option>
+            <option value="G">Green</option>
+            <option value="B">Blue</option>
+        </select>
+    """
+    )
+    locator = page.locator("select")
+    locator.select_option(["R", "G"])
+    expect(locator).to_have_values(["R", "G"])
+
+
+def test_to_have_values_follows_labels(page: Page, server: Server) -> None:
+    page.set_content(
+        """
+        <label for="colors">Pick a Color</label>
+        <select id="colors" multiple>
+            <option value="R">Red</option>
+            <option value="G">Green</option>
+            <option value="B">Blue</option>
+        </select>
+    """
+    )
+    locator = page.locator("text=Pick a Color")
+    locator.select_option(["R", "G"])
+    expect(locator).to_have_values(["R", "G"])
+
+
+def test_to_have_values_exact_match_with_text(page: Page, server: Server) -> None:
+    page.set_content(
+        """
+        <select multiple>
+            <option value="RR">Red</option>
+            <option value="GG">Green</option>
+        </select>
+    """
+    )
+    locator = page.locator("select")
+    locator.select_option(["RR", "GG"])
+    with pytest.raises(AssertionError) as excinfo:
+        expect(locator).to_have_values(["R", "G"], timeout=500)
+    assert "Locator expected to have Values '['R', 'G']'" in str(excinfo.value)
+    assert "Actual value: ['RR', 'GG']" in str(excinfo.value)
+
+
+def test_to_have_values_works_with_regex(page: Page, server: Server) -> None:
+    page.set_content(
+        """
+        <select multiple>
+            <option value="R">Red</option>
+            <option value="G">Green</option>
+            <option value="B">Blue</option>
+        </select>
+    """
+    )
+    locator = page.locator("select")
+    locator.select_option(["R", "G"])
+    expect(locator).to_have_values([re.compile("R"), re.compile("G")])
+
+
+def test_to_have_values_fails_when_items_not_selected(
+    page: Page, server: Server
+) -> None:
+    page.set_content(
+        """
+        <select multiple>
+            <option value="R">Red</option>
+            <option value="G">Green</option>
+            <option value="B">Blue</option>
+        </select>
+    """
+    )
+    locator = page.locator("select")
+    locator.select_option(["B"])
+    with pytest.raises(AssertionError) as excinfo:
+        expect(locator).to_have_values(["R", "G"], timeout=500)
+    assert "Locator expected to have Values '['R', 'G']'" in str(excinfo.value)
+    assert "Actual value: ['B']" in str(excinfo.value)
+
+
+def test_to_have_values_fails_when_multiple_not_specified(
+    page: Page, server: Server
+) -> None:
+    page.set_content(
+        """
+        <select>
+            <option value="R">Red</option>
+            <option value="G">Green</option>
+            <option value="B">Blue</option>
+        </select>
+    """
+    )
+    locator = page.locator("select")
+    locator.select_option(["B"])
+    with pytest.raises(AssertionError) as excinfo:
+        expect(locator).to_have_values(["R", "G"], timeout=500)
+    assert "Error: Not a select element with a multiple attribute" in str(excinfo.value)
+
+
+def test_to_have_values_fails_when_not_a_select_element(
+    page: Page, server: Server
+) -> None:
+    page.set_content(
+        """
+        <input type="text">
+    """
+    )
+    locator = page.locator("input")
+    with pytest.raises(AssertionError) as excinfo:
+        expect(locator).to_have_values(["R", "G"], timeout=500)
+    assert "Error: Not a select element with a multiple attribute" in str(excinfo.value)
+
+
+def test_assertions_locator_to_be_checked(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<input type=checkbox>")
+    my_checkbox = page.locator("input")
+    expect(my_checkbox).not_to_be_checked()
+    with pytest.raises(AssertionError, match="Locator expected to be checked"):
+        expect(my_checkbox).to_be_checked(timeout=100)
+    expect(my_checkbox).to_be_checked(timeout=100, checked=False)
+    with pytest.raises(AssertionError):
+        expect(my_checkbox).to_be_checked(timeout=100, checked=True)
+    my_checkbox.check()
+    expect(my_checkbox).to_be_checked(timeout=100, checked=True)
+    with pytest.raises(AssertionError, match="Locator expected to be unchecked"):
+        expect(my_checkbox).to_be_checked(timeout=100, checked=False)
+    expect(my_checkbox).to_be_checked()
+
+
+def test_assertions_boolean_checked_with_intermediate_true(page: Page) -> None:
+    page.set_content("<input type=checkbox></input>")
+    page.locator("input").evaluate("e => e.indeterminate = true")
+    expect(page.locator("input")).to_be_checked(indeterminate=True)
+
+
+def test_assertions_boolean_checked_with_intermediate_true_and_checked(
+    page: Page,
+) -> None:
+    page.set_content("<input type=checkbox></input>")
+    page.locator("input").evaluate("e => e.indeterminate = true")
+    with pytest.raises(
+        AssertionError, match="Can't assert indeterminate and checked at the same time"
+    ):
+        expect(page.locator("input")).to_be_checked(checked=False, indeterminate=True)
+
+
+def test_assertions_boolean_fail_with_indeterminate_true(page: Page) -> None:
+    page.set_content("<input type=checkbox></input>")
+    with pytest.raises(
+        AssertionError, match='Expect "to_be_checked" with timeout 1000ms'
+    ):
+        expect(page.locator("input")).to_be_checked(indeterminate=True, timeout=1000)
+
+
+def test_assertions_locator_to_be_disabled_enabled(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<input type=checkbox>")
+    my_checkbox = page.locator("input")
+    expect(my_checkbox).not_to_be_disabled()
+    expect(my_checkbox).to_be_enabled()
+    with pytest.raises(AssertionError):
+        expect(my_checkbox).to_be_disabled(timeout=100)
+    my_checkbox.evaluate("e => e.disabled = true")
+    expect(my_checkbox).to_be_disabled()
+    with pytest.raises(AssertionError, match="Locator expected to be enabled"):
+        expect(my_checkbox).to_be_enabled(timeout=100)
+
+
+def test_assertions_locator_to_be_enabled_with_true(page: Page) -> None:
+    page.set_content("<button>Text</button>")
+    expect(page.locator("button")).to_be_enabled(enabled=True)
+
+
+def test_assertions_locator_to_be_enabled_with_false_throws_good_exception(
+    page: Page,
+) -> None:
+    page.set_content("<button>Text</button>")
+    with pytest.raises(AssertionError, match="Locator expected to be disabled"):
+        expect(page.locator("button")).to_be_enabled(enabled=False)
+
+
+def test_assertions_locator_to_be_enabled_with_false(page: Page) -> None:
+    page.set_content("<button disabled>Text</button>")
+    expect(page.locator("button")).to_be_enabled(enabled=False)
+
+
+def test_assertions_locator_to_be_enabled_with_not_and_false(page: Page) -> None:
+    page.set_content("<button>Text</button>")
+    expect(page.locator("button")).not_to_be_enabled(enabled=False)
+
+
+def test_assertions_locator_to_be_enabled_eventually(page: Page) -> None:
+    page.set_content("<button disabled>Text</button>")
+    page.eval_on_selector(
+        "button",
+        """
+        button => setTimeout(() => {
+            button.removeAttribute('disabled');
+        }, 700);
+    """,
+    )
+    expect(page.locator("button")).to_be_enabled()
+
+
+def test_assertions_locator_to_be_enabled_eventually_with_not(page: Page) -> None:
+    page.set_content("<button>Text</button>")
+    page.eval_on_selector(
+        "button",
+        """
+        button => setTimeout(() => {
+            button.setAttribute('disabled', '');
+        }, 700);
+    """,
+    )
+    expect(page.locator("button")).not_to_be_enabled()
+
+
+def test_assertions_locator_to_be_editable(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<input></input>")
+    expect(page.locator("input")).to_be_editable()
+
+
+def test_assertions_locator_to_be_editable_throws(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<button disabled>Text</button>")
+    with pytest.raises(
+        AssertionError,
+        match=r"Element is not an <input>, <textarea>, <select> or \[contenteditable\] and does not have a role allowing \[aria-readonly\]",
+    ):
+        expect(page.locator("button")).not_to_be_editable()
+
+
+def test_assertions_locator_to_be_editable_with_true(page: Page) -> None:
+    page.set_content("<input></input>")
+    expect(page.locator("input")).to_be_editable(editable=True)
+
+
+def test_assertions_locator_to_be_editable_with_false(page: Page) -> None:
+    page.set_content("<input readonly></input>")
+    expect(page.locator("input")).to_be_editable(editable=False)
+
+
+def test_assertions_locator_to_be_editable_with_false_and_throw_good_exception(
+    page: Page,
+) -> None:
+    page.set_content("<input></input>")
+    with pytest.raises(AssertionError, match="Locator expected to be readonly"):
+        expect(page.locator("input")).to_be_editable(editable=False)
+
+
+def test_assertions_locator_to_be_editable_with_not_and_false(page: Page) -> None:
+    page.set_content("<input></input>")
+    expect(page.locator("input")).not_to_be_editable(editable=False)
+
+
+def test_assertions_locator_to_be_empty(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content(
+        "<input value=text name=input1></input><input name=input2></input>"
+    )
+    expect(page.locator("input[name=input1]")).not_to_be_empty()
+    expect(page.locator("input[name=input2]")).to_be_empty()
+    with pytest.raises(AssertionError):
+        expect(page.locator("input[name=input1]")).to_be_empty(timeout=100)
+
+
+def test_assertions_locator_to_be_focused(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<input type=checkbox>")
+    my_checkbox = page.locator("input")
+    with pytest.raises(AssertionError):
+        expect(my_checkbox).to_be_focused(timeout=100)
+    my_checkbox.focus()
+    expect(my_checkbox).to_be_focused()
+
+
+def test_assertions_locator_to_be_hidden_visible(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div style='width: 50px; height: 50px;'>Something</div>")
+    my_checkbox = page.locator("div")
+    expect(my_checkbox).to_be_visible()
+    with pytest.raises(AssertionError):
+        expect(my_checkbox).to_be_hidden(timeout=100)
+    my_checkbox.evaluate("e => e.style.display = 'none'")
+    expect(my_checkbox).to_be_hidden()
+    with pytest.raises(AssertionError, match="Locator expected to be visible"):
+        expect(my_checkbox).to_be_visible(timeout=100)
+
+
+def test_assertions_locator_to_be_visible_with_true(page: Page) -> None:
+    page.set_content("<button>hello</button>")
+    expect(page.locator("button")).to_be_visible(visible=True)
+
+
+def test_assertions_locator_to_be_visible_with_false(page: Page) -> None:
+    page.set_content("<button hidden>hello</button>")
+    expect(page.locator("button")).to_be_visible(visible=False)
+
+
+def test_assertions_locator_to_be_visible_with_false_throws_good_exception(
+    page: Page,
+) -> None:
+    page.set_content("<button>hello</button>")
+    with pytest.raises(AssertionError, match="Locator expected to be hidden"):
+        expect(page.locator("button")).to_be_visible(visible=False)
+
+
+def test_assertions_locator_to_be_visible_with_not_and_false(page: Page) -> None:
+    page.set_content("<button>hello</button>")
+    expect(page.locator("button")).not_to_be_visible(visible=False)
+
+
+def test_assertions_locator_to_be_visible_eventually(page: Page) -> None:
+    page.set_content("<div></div>")
+    page.eval_on_selector(
+        "div",
+        """
+        div => setTimeout(() => {
+            div.innerHTML = '<span>Hello</span>';
+        }, 700);
+    """,
+    )
+    expect(page.locator("span")).to_be_visible()
+
+
+def test_assertions_locator_to_be_visible_eventually_with_not(page: Page) -> None:
+    page.set_content("<div><span>Hello</span></div>")
+    page.eval_on_selector(
+        "span",
+        """
+        span => setTimeout(() => {
+            span.textContent = '';
+        }, 700);
+    """,
+    )
+    expect(page.locator("span")).not_to_be_visible()
+
+
+def test_assertions_should_serialize_regexp_correctly(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<div>iGnOrEcAsE</div>")
+    expect(page.locator("div")).to_have_text(re.compile(r"ignorecase", re.IGNORECASE))
+    page.set_content(
+        """<div>start
+some
+lines
+between
+end</div>"""
+    )
+    expect(page.locator("div")).to_have_text(re.compile(r"start.*end", re.DOTALL))
+    page.set_content(
+        """<div>line1
+line2
+line3</div>"""
+    )
+    expect(page.locator("div")).to_have_text(re.compile(r"^line2$", re.MULTILINE))
+
+
+def test_assertions_response_is_ok_pass(page: Page, server: Server) -> None:
+    response = page.request.get(server.EMPTY_PAGE)
+    expect(response).to_be_ok()
+
+
+def test_assertions_response_is_ok_pass_with_not(page: Page, server: Server) -> None:
+    response = page.request.get(server.PREFIX + "/unknown")
+    expect(response).not_to_be_ok()
+
+
+def test_assertions_response_is_ok_fail(page: Page, server: Server) -> None:
+    response = page.request.get(server.PREFIX + "/unknown")
+    with pytest.raises(AssertionError) as excinfo:
+        expect(response).to_be_ok()
+    error_message = str(excinfo.value)
+    assert ("→ GET " + server.PREFIX + "/unknown") in error_message
+    assert "← 404 Not Found" in error_message
+
+
+def test_should_print_response_with_text_content_type_if_to_be_ok_fails(
+    page: Page, server: Server
+) -> None:
+    server.set_route(
+        "/text-content-type",
+        lambda r: (
+            r.setResponseCode(404),
+            r.setHeader("content-type", "text/plain"),
+            r.write(b"Text error"),
+            r.finish(),
+        ),
+    )
+    server.set_route(
+        "/no-content-type",
+        lambda r: (
+            r.setResponseCode(404),
+            r.write(b"No content type error"),
+            r.finish(),
+        ),
+    )
+    server.set_route(
+        "/binary-content-type",
+        lambda r: (
+            r.setResponseCode(404),
+            r.setHeader("content-type", "image/bmp"),
+            r.write(b"Image content type error"),
+            r.finish(),
+        ),
+    )
+
+    response = page.request.get(server.PREFIX + "/text-content-type")
+    with pytest.raises(AssertionError) as excinfo:
+        expect(response).to_be_ok()
+    error_message = str(excinfo.value)
+    assert ("→ GET " + server.PREFIX + "/text-content-type") in error_message
+    assert "← 404 Not Found" in error_message
+    assert "Response Text:" in error_message
+    assert "Text error" in error_message
+
+    response = page.request.get(server.PREFIX + "/no-content-type")
+    with pytest.raises(AssertionError) as excinfo:
+        expect(response).to_be_ok()
+    error_message = str(excinfo.value)
+    assert ("→ GET " + server.PREFIX + "/no-content-type") in error_message
+    assert "← 404 Not Found" in error_message
+    assert "Response Text:" not in error_message
+    assert "No content type error" not in error_message
+
+    response = page.request.get(server.PREFIX + "/binary-content-type")
+    with pytest.raises(AssertionError) as excinfo:
+        expect(response).to_be_ok()
+    error_message = str(excinfo.value)
+    assert ("→ GET " + server.PREFIX + "/binary-content-type") in error_message
+    assert "← 404 Not Found" in error_message
+    assert "Response Text:" not in error_message
+    assert "Image content type error" not in error_message
+
+
+def test_should_print_users_message_for_page_based_assertion(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<title>new title</title>")
+    with pytest.raises(AssertionError) as excinfo:
+        expect(page, "Title is not new").to_have_title("old title", timeout=100)
+    assert "Title is not new" in str(excinfo.value)
+    with pytest.raises(AssertionError) as excinfo:
+        expect(page).to_have_title("old title", timeout=100)
+    assert "Page title expected to be" in str(excinfo.value)
+
+
+def test_should_print_expected_value_with_custom_message(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<title>new title</title>")
+    with pytest.raises(AssertionError) as excinfo:
+        expect(page, "custom-message").to_have_title("old title", timeout=100)
+    assert "custom-message" in str(excinfo.value)
+    assert "Expected value: 'old title'" in str(excinfo.value)
+    with pytest.raises(AssertionError) as excinfo:
+        expect(page.get_by_text("hello"), "custom-message").to_be_visible(timeout=100)
+    assert "custom-message" in str(excinfo.value)
+    assert "Expected value" not in str(excinfo.value)
+
+
+def test_should_be_attached_default(page: Page) -> None:
+    page.set_content("<input></input>")
+    locator = page.locator("input")
+    expect(locator).to_be_attached()
+
+
+def test_should_be_attached_with_hidden_element(page: Page) -> None:
+    page.set_content('<button style="display:none">hello</button>')
+    locator = page.locator("button")
+    expect(locator).to_be_attached()
+
+
+def test_should_be_attached_with_not(page: Page) -> None:
+    page.set_content("<button>hello</button>")
+    locator = page.locator("input")
+    expect(locator).not_to_be_attached()
+
+
+def test_should_be_attached_with_attached_true(page: Page) -> None:
+    page.set_content("<button>hello</button>")
+    locator = page.locator("button")
+    expect(locator).to_be_attached(attached=True)
+
+
+def test_should_be_attached_with_attached_false(page: Page) -> None:
+    page.set_content("<button>hello</button>")
+    locator = page.locator("input")
+    expect(locator).to_be_attached(attached=False)
+
+
+def test_should_be_attached_with_attached_false_and_throw_good_error(
+    page: Page,
+) -> None:
+    page.set_content("<button>hello</button>")
+    locator = page.locator("button")
+    with pytest.raises(AssertionError, match="Locator expected to be detached"):
+        expect(locator).to_be_attached(attached=False, timeout=1)
+
+
+def test_should_be_attached_with_not_and_attached_false(page: Page) -> None:
+    page.set_content("<button>hello</button>")
+    locator = page.locator("button")
+    expect(locator).not_to_be_attached(attached=False)
+
+
+def test_should_be_attached_eventually(page: Page) -> None:
+    page.set_content("<div></div>")
+    locator = page.locator("span")
+    page.locator("div").evaluate(
+        "(e) => setTimeout(() => e.innerHTML = '<span>hello</span>', 1000)"
+    )
+    expect(locator).to_be_attached()
+
+
+def test_should_be_attached_eventually_with_not(page: Page) -> None:
+    page.set_content("<div><span>Hello</span></div>")
+    locator = page.locator("span")
+    page.locator("div").evaluate("(e) => setTimeout(() => e.textContent = '', 1000)")
+    expect(locator).not_to_be_attached()
+
+
+def test_should_be_attached_fail(page: Page) -> None:
+    page.set_content("<button>Hello</button>")
+    locator = page.locator("input")
+    with pytest.raises(
+        AssertionError, match="Locator expected to be attached"
+    ) as exc_info:
+        expect(locator).to_be_attached(timeout=1000)
+    assert "locator resolved to" not in exc_info.value.args[0]
+
+
+def test_should_be_attached_fail_with_not(page: Page) -> None:
+    page.set_content("<input></input>")
+    locator = page.locator("input")
+    with pytest.raises(AssertionError) as exc_info:
+        expect(locator).not_to_be_attached(timeout=1000)
+    assert "locator resolved to <input/>" in exc_info.value.args[0]
+
+
+def test_should_be_attached_with_impossible_timeout(page: Page) -> None:
+    page.set_content("<div id=node>Text content</div>")
+    expect(page.locator("#node")).to_be_attached(timeout=1)
+
+
+def test_should_be_attached_with_impossible_timeout_not(page: Page) -> None:
+    page.set_content("<div id=node>Text content</div>")
+    expect(page.locator("no-such-thing")).not_to_be_attached(timeout=1)
+
+
+def test_should_be_able_to_set_custom_timeout(page: Page) -> None:
+    with pytest.raises(AssertionError) as exc_info:
+        expect(page.locator("#a1")).to_be_visible(timeout=111)
+    assert 'Expect "to_be_visible" with timeout 111ms' in str(exc_info.value)
+
+
+def test_should_be_able_to_set_custom_global_timeout(page: Page) -> None:
+    try:
+        expect.set_options(timeout=111)
+        with pytest.raises(AssertionError) as exc_info:
+            expect(page.locator("#a1")).to_be_visible()
+        assert 'Expect "to_be_visible" with timeout 111ms' in str(exc_info.value)
+    finally:
+        expect.set_options(timeout=5_000)
+
+
+def test_to_have_accessible_name(page: Page) -> None:
+    page.set_content('<div role="button" aria-label="Hello"></div>')
+    locator = page.locator("div")
+    expect(locator).to_have_accessible_name("Hello")
+    expect(locator).not_to_have_accessible_name("hello")
+    expect(locator).to_have_accessible_name("hello", ignore_case=True)
+    expect(locator).to_have_accessible_name(re.compile(r"ell\w"))
+    expect(locator).not_to_have_accessible_name(re.compile(r"hello"))
+    expect(locator).to_have_accessible_name(re.compile(r"hello"), ignore_case=True)
+
+    page.set_content("<button>foo&nbsp;bar\nbaz</button>")
+    expect(page.locator("button")).to_have_accessible_name("foo bar baz")
+
+
+def test_to_have_accessible_error_message(page: Page) -> None:
+    page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error-message" />
+        <div id="error-message">Hello</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+    expect(locator).to_have_accessible_error_message("Hello")
+    expect(locator).not_to_have_accessible_error_message("hello")
+    expect(locator).to_have_accessible_error_message("hello", ignore_case=True)
+    expect(locator).to_have_accessible_error_message(re.compile(r"ell\w"))
+    expect(locator).not_to_have_accessible_error_message(re.compile(r"hello"))
+    expect(locator).to_have_accessible_error_message(
+        re.compile(r"hello"), ignore_case=True
+    )
+    expect(locator).not_to_have_accessible_error_message(
+        "This should not be considered."
+    )
+
+
+def test_to_have_accessible_error_message_should_handle_multiple_aria_error_message_references(
+    page: Page,
+) -> None:
+    page.set_content(
+        """
+      <form>
+        <input role="textbox" aria-invalid="true" aria-errormessage="error1 error2" />
+        <div id="error1">First error message.</div>
+        <div id="error2">Second error message.</div>
+        <div id="irrelevant-error">This should not be considered.</div>
+      </form>
+    """
+    )
+
+    locator = page.locator('input[role="textbox"]')
+
+    expect(locator).to_have_accessible_error_message(
+        "First error message. Second error message."
+    )
+    expect(locator).to_have_accessible_error_message(
+        re.compile(r"first error message.", re.IGNORECASE)
+    )
+    expect(locator).to_have_accessible_error_message(
+        re.compile(r"second error message.", re.IGNORECASE)
+    )
+    expect(locator).not_to_have_accessible_error_message(
+        re.compile(r"This should not be considered.", re.IGNORECASE)
+    )
+
+
+def test_to_have_accessible_description(page: Page) -> None:
+    page.set_content('<div role="button" aria-description="Hello"></div>')
+    locator = page.locator("div")
+    expect(locator).to_have_accessible_description("Hello")
+    expect(locator).not_to_have_accessible_description("hello")
+    expect(locator).to_have_accessible_description("hello", ignore_case=True)
+    expect(locator).to_have_accessible_description(re.compile(r"ell\w"))
+    expect(locator).not_to_have_accessible_description(re.compile(r"hello"))
+    expect(locator).to_have_accessible_description(
+        re.compile(r"hello"), ignore_case=True
+    )
+
+    page.set_content(
+        """
+        <div role="button" aria-describedby="desc"></div>
+        <span id="desc">foo&nbsp;bar\nbaz</span>
+    """
+    )
+    expect(page.locator("div")).to_have_accessible_description("foo bar baz")
+
+
+def test_to_have_role(page: Page) -> None:
+    page.set_content('<div role="button">Button!</div>')
+    expect(page.locator("div")).to_have_role("button")
+    expect(page.locator("div")).not_to_have_role("checkbox")
+    with pytest.raises(Error) as excinfo:
+        expect(page.locator("div")).to_have_role(re.compile(r"button|checkbox"))  # type: ignore
+    assert '"role" argument in to_have_role must be a string' in str(excinfo.value)
+
+
+def test_soft_outside_scope_raises_runtime_error(page: Page, server: Server) -> None:
+    page.set_content("<div>hello</div>")
+    with pytest.raises(RuntimeError, match="pytest-playwright"):
+        expect.soft(page.locator("div")).to_have_text("nope", timeout=500)
+
+
+def test_soft_inside_scope_collects_failures(page: Page, server: Server) -> None:
+    from playwright._impl._assertions import _soft_scope
+
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<title>actual</title><div>hello</div>")
+
+    with _soft_scope() as errors:
+        expect.soft(page).to_have_title("expected", timeout=500)
+        expect.soft(page.locator("div")).to_have_text("goodbye", timeout=500)
+        expect.soft(page.locator("div")).to_have_text("hello")
+        expect.soft(page.locator("div")).not_to_have_text("hello", timeout=500)
+
+    assert len(errors) == 3
+    assert all(isinstance(e, AssertionError) for e in errors)
+
+
+def test_assertions_should_include_aria_snapshot_in_separate_section(
+    page: Page,
+) -> None:
+    page.set_content(
+        """
+        <div id="hidden" style="display: none"><span>secret</span></div>
+        <main><h1>Page Heading</h1></main>
+        """
+    )
+    with pytest.raises(AssertionError) as excinfo:
+        expect(page.locator("#hidden")).to_be_visible(timeout=500)
+    message = str(excinfo.value)
+    assert "Aria snapshot:" in message
+    # The aria snapshot lives in its own section, not in the "Actual value" line.
+    assert "Actual value: hidden" in message
+    actual_line = message.split("\n")[1]
+    assert 'heading "Page Heading"' not in actual_line
+    assert message.index('heading "Page Heading"') > message.index("Aria snapshot:")
diff --git a/tests/sync/test_browser.py b/tests/sync/test_browser.py
new file mode 100644
index 000000000..deaf03ea1
--- /dev/null
+++ b/tests/sync/test_browser.py
@@ -0,0 +1,47 @@
+# 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.
+
+from typing import Dict
+
+from playwright.sync_api import Browser, BrowserType
+
+
+def test_should_return_browser_type(
+    browser: Browser, browser_type: BrowserType
+) -> None:
+    assert browser.browser_type is browser_type
+
+
+def test_bind_should_return_endpoint_and_allow_unbind(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
+    browser = browser_type.launch(**launch_arguments)
+    try:
+        result = browser.bind("test-server")
+        assert "endpoint" in result
+        assert isinstance(result["endpoint"], str)
+        assert len(result["endpoint"]) > 0
+        browser.unbind()
+    finally:
+        browser.close()
+
+
+def test_should_fire_context_event_on_new_context(browser: Browser) -> None:
+    events = []
+    browser.on("context", lambda ctx: events.append(ctx))
+    context = browser.new_context()
+    try:
+        assert events == [context]
+    finally:
+        context.close()
diff --git a/tests/sync/test_browsercontext_client_certificates.py b/tests/sync/test_browsercontext_client_certificates.py
new file mode 100644
index 000000000..7a6d4f8cf
--- /dev/null
+++ b/tests/sync/test_browsercontext_client_certificates.py
@@ -0,0 +1,258 @@
+# 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 sys
+import threading
+from pathlib import Path
+from typing import Dict, Generator, Optional, cast
+
+import OpenSSL.crypto
+import OpenSSL.SSL
+import pytest
+from twisted.internet import reactor as _twisted_reactor
+from twisted.internet import ssl
+from twisted.internet.selectreactor import SelectReactor
+from twisted.web import resource, server
+from twisted.web.http import Request
+
+from playwright.sync_api import Browser, BrowserType, Playwright, expect
+
+reactor = cast(SelectReactor, _twisted_reactor)
+
+
+@pytest.fixture(scope="function", autouse=True)
+def _skip_webkit_darwin(browser_name: str) -> None:
+    if browser_name == "webkit" and sys.platform == "darwin":
+        pytest.skip("WebKit does not proxy localhost on macOS")
+
+
+class HttpsResource(resource.Resource):
+    serverCertificate: ssl.PrivateCertificate
+    isLeaf = True
+
+    def _verify_cert_chain(self, cert: Optional[OpenSSL.crypto.X509]) -> bool:
+        if not cert:
+            return False
+        store = OpenSSL.crypto.X509Store()
+        store.add_cert(self.serverCertificate.original)
+        store_ctx = OpenSSL.crypto.X509StoreContext(store, cert)
+        try:
+            store_ctx.verify_certificate()
+            return True
+        except OpenSSL.crypto.X509StoreContextError:
+            return False
+
+    def render_GET(self, request: Request) -> bytes:
+        tls_socket: OpenSSL.SSL.Connection = request.transport.getHandle()  # type: ignore
+        cert = tls_socket.get_peer_certificate()
+        parts = []
+
+        if self._verify_cert_chain(cert):
+            request.setResponseCode(200)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": f"Hello {cert.get_subject().CN}, your certificate was issued by {cert.get_issuer().CN}!",  # type: ignore
+                }
+            )
+        elif cert and cert.get_subject():
+            request.setResponseCode(403)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": f"Sorry {cert.get_subject().CN}, certificates from {cert.get_issuer().CN} are not welcome here.",
+                }
+            )
+        else:
+            request.setResponseCode(401)
+            parts.append(
+                {
+                    "key": "message",
+                    "value": "Sorry, but you need to provide a client certificate to continue.",
+                }
+            )
+        return b"".join(
+            [
+                f'<div data-testid="{part["key"]}">{part["value"]}</div>'.encode()
+                for part in parts
+            ]
+        )
+
+
+@pytest.fixture(scope="session", autouse=True)
+def _client_certificate_server(assetdir: Path) -> Generator[None, None, None]:
+    certAuthCert = ssl.Certificate.loadPEM(
+        (assetdir / "client-certificates/server/server_cert.pem").read_text()
+    )
+    serverCert = ssl.PrivateCertificate.loadPEM(
+        (assetdir / "client-certificates/server/server_key.pem").read_text()
+        + (assetdir / "client-certificates/server/server_cert.pem").read_text()
+    )
+
+    contextFactory = serverCert.options(certAuthCert)
+    contextFactory.requireCertificate = False
+    resource = HttpsResource()
+    resource.serverCertificate = serverCert
+    site = server.Site(resource)
+
+    def _run() -> None:
+        reactor.listenSSL(8000, site, contextFactory)
+
+    thread = threading.Thread(target=_run)
+    thread.start()
+    yield
+    thread.join()
+
+
+def test_should_throw_with_untrusted_client_certs(
+    playwright: Playwright, assetdir: Path
+) -> None:
+    serverURL = "https://localhost:8000/"
+    request = playwright.request.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": serverURL,
+                "certPath": assetdir
+                / "client-certificates/client/self-signed/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/self-signed/key.pem",
+            }
+        ],
+    )
+    with pytest.raises(Exception, match="alert unknown ca"):
+        request.get(serverURL)
+    request.dispose()
+
+
+def test_should_work_with_new_context(browser: Browser, assetdir: Path) -> None:
+    context = browser.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    page = context.new_page()
+    page.goto("https://localhost:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    page.goto("https://127.0.0.1:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+
+    response = page.context.request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in response.text()
+    )
+    response = page.context.request.get("https://127.0.0.1:8000")
+    assert "Hello Alice, your certificate was issued by localhost!" in response.text()
+    context.close()
+
+
+def test_should_work_with_new_context_passing_as_content(
+    browser: Browser, assetdir: Path
+) -> None:
+    context = browser.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "cert": (
+                    assetdir / "client-certificates/client/trusted/cert.pem"
+                ).read_bytes(),
+                "key": (
+                    assetdir / "client-certificates/client/trusted/key.pem"
+                ).read_bytes(),
+            }
+        ],
+    )
+    page = context.new_page()
+    page.goto("https://localhost:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    page.goto("https://127.0.0.1:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+
+    response = page.context.request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in response.text()
+    )
+    response = page.context.request.get("https://127.0.0.1:8000")
+    assert "Hello Alice, your certificate was issued by localhost!" in response.text()
+    context.close()
+
+
+def test_should_work_with_new_persistent_context(
+    browser_type: BrowserType, assetdir: Path, launch_arguments: Dict
+) -> None:
+    context = browser_type.launch_persistent_context(
+        "",
+        **launch_arguments,
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    page = context.new_page()
+    page.goto("https://localhost:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Sorry, but you need to provide a client certificate to continue."
+    )
+    page.goto("https://127.0.0.1:8000")
+    expect(page.get_by_test_id("message")).to_have_text(
+        "Hello Alice, your certificate was issued by localhost!"
+    )
+    context.close()
+
+
+def test_should_work_with_global_api_request_context(
+    playwright: Playwright, assetdir: Path
+) -> None:
+    request = playwright.request.new_context(
+        # TODO: Remove this once we can pass a custom CA.
+        ignore_https_errors=True,
+        client_certificates=[
+            {
+                "origin": "https://127.0.0.1:8000",
+                "certPath": assetdir / "client-certificates/client/trusted/cert.pem",
+                "keyPath": assetdir / "client-certificates/client/trusted/key.pem",
+            }
+        ],
+    )
+    response = request.get("https://localhost:8000")
+    assert (
+        "Sorry, but you need to provide a client certificate to continue."
+        in response.text()
+    )
+    response = request.get("https://127.0.0.1:8000")
+    assert "Hello Alice, your certificate was issued by localhost!" in response.text()
+    request.dispose()
diff --git a/tests/sync/test_browsercontext_events.py b/tests/sync/test_browsercontext_events.py
new file mode 100644
index 000000000..9e1c42c3e
--- /dev/null
+++ b/tests/sync/test_browsercontext_events.py
@@ -0,0 +1,318 @@
+# 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.
+
+from typing import Optional
+
+import pytest
+
+from playwright.sync_api import BrowserContext, Dialog, Page
+
+from ..server import Server, TestServerRequest
+
+
+def test_console_event_should_work(page: Page) -> None:
+    with page.context.expect_console_message() as console_info:
+        page.evaluate("() => console.log('hello')")
+    message = console_info.value
+    assert message.text == "hello"
+    assert message.page == page
+
+
+def test_console_event_should_work_in_popup(page: Page) -> None:
+    with page.context.expect_console_message() as console_info:
+        with page.expect_popup() as popup_info:
+            page.evaluate(
+                """() => {
+                const win = window.open('');
+                win.console.log('hello');
+                }"""
+            )
+    message = console_info.value
+    popup = popup_info.value
+    assert message.text == "hello"
+    assert message.page == popup
+
+
+# console message from javascript: url is not reported at all
+@pytest.mark.skip_browser("firefox")
+def test_console_event_should_work_in_popup_2(page: Page, browser_name: str) -> None:
+    with page.context.expect_console_message(
+        lambda msg: msg.type == "log"
+    ) as console_info:
+        with page.context.expect_page() as page_info:
+            page.evaluate(
+                """async () => {
+                const win = window.open('javascript:console.log("hello")');
+                await new Promise(f => setTimeout(f, 0));
+                win.close();
+            }"""
+            )
+    message = console_info.value
+    popup = page_info.value
+    assert message.text == "hello"
+    assert message.page == popup
+
+
+# console message from javascript: url is not reported at all
+@pytest.mark.skip_browser("firefox")
+def test_console_event_should_work_in_immediately_closed_popup(
+    page: Page, browser_name: str
+) -> None:
+    with page.context.expect_console_message(
+        lambda msg: msg.type == "log"
+    ) as console_info:
+        with page.context.expect_page() as page_info:
+            page.evaluate(
+                """() => {
+                const win = window.open('');
+                win.console.log('hello');
+                win.close();
+            }"""
+            )
+    message = console_info.value
+    popup = page_info.value
+    assert message.text == "hello"
+    assert message.page == popup
+
+
+def test_dialog_event_should_work1(page: Page) -> None:
+    dialog1: Optional[Dialog] = None
+
+    def handle_page_dialog(dialog: Dialog) -> None:
+        nonlocal dialog1
+        dialog1 = dialog
+        dialog.accept("hello")
+
+    page.on("dialog", handle_page_dialog)
+
+    dialog2: Optional[Dialog] = None
+
+    def handle_context_dialog(dialog: Dialog) -> None:
+        nonlocal dialog2
+        dialog2 = dialog
+
+    page.context.on("dialog", handle_context_dialog)
+
+    assert page.evaluate("() => prompt('hey?')") == "hello"
+    assert dialog1
+    assert dialog1 == dialog2
+    assert dialog1.message == "hey?"
+    assert dialog1.page == page
+
+
+def test_dialog_event_should_work_in_popup1(page: Page) -> None:
+    dialog: Optional[Dialog] = None
+
+    def handle_dialog(d: Dialog) -> None:
+        nonlocal dialog
+        dialog = d
+        dialog.accept("hello")
+
+    page.context.on("dialog", handle_dialog)
+
+    with page.expect_popup() as popup_info:
+        assert page.evaluate("() => window.open('').prompt('hey?')") == "hello"
+    popup = popup_info.value
+    assert dialog
+    assert dialog.message == "hey?"
+    assert dialog.page == popup
+
+
+# console message from javascript: url is not reported at all
+@pytest.mark.skip_browser("firefox")
+def test_dialog_event_should_work_in_popup_2(page: Page, browser_name: str) -> None:
+    def handle_dialog(dialog: Dialog) -> None:
+        assert dialog.message == "hey?"
+        assert dialog.page is None
+        dialog.accept("hello")
+
+    page.context.on("dialog", handle_dialog)
+
+    assert page.evaluate("() => window.open('javascript:prompt(\"hey?\")')")
+
+
+# console message from javascript: url is not reported at all
+@pytest.mark.skip_browser("firefox")
+def test_dialog_event_should_work_in_immdiately_closed_popup(page: Page) -> None:
+    popup = None
+
+    def handle_popup(p: Page) -> None:
+        nonlocal popup
+        popup = p
+
+    page.on("popup", handle_popup)
+
+    with page.context.expect_console_message() as console_info:
+        page.evaluate(
+            """() => {
+                const win = window.open();
+                win.console.log('hello');
+                win.close();
+            }"""
+        )
+    message = console_info.value
+
+    assert message.text == "hello"
+    assert message.page == popup
+
+
+def test_dialog_event_should_work_with_inline_script_tag(
+    page: Page, server: Server
+) -> None:
+    def handle_route(request: TestServerRequest) -> None:
+        request.setHeader("content-type", "text/html")
+        request.write(b"<script>window.result = prompt('hey?')</script>")
+        request.finish()
+
+    server.set_route("/popup.html", handle_route)
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<a href='popup.html' target=_blank>Click me</a>")
+
+    with (
+        page.context.expect_event("dialog") as dialog_info,
+        page.expect_popup() as popup_info,
+    ):
+        page.click("a")
+
+    dialog: Dialog = dialog_info.value
+    popup: Page = popup_info.value
+
+    assert dialog.message == "hey?"
+    assert dialog.page == popup
+    dialog.accept("hello")
+    assert popup.evaluate("window.result") == "hello"
+
+
+def test_console_event_should_work_with_context_manager(page: Page) -> None:
+    with page.context.expect_console_message() as cm_info:
+        page.evaluate("() => console.log('hello')")
+    message = cm_info.value
+    assert message.text == "hello"
+    assert message.page == page
+
+
+def test_weberror_event_should_work(context: BrowserContext, page: Page) -> None:
+    with context.expect_event("weberror") as error_info:
+        page.goto('data:text/html,<script>throw new Error("Test")</script>')
+    error = error_info.value
+    assert error.page == page
+    assert error.error.message == "Test"
+
+
+def test_weberror_event_should_include_location(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    def handle_error_js(request: TestServerRequest) -> None:
+        request.setHeader("content-type", "application/javascript")
+        request.write(
+            b"""
+            function foo() {
+                throw new Error('boom');
+            }
+            foo();
+            """
+        )
+        request.finish()
+
+    def handle_error_html(request: TestServerRequest) -> None:
+        request.setHeader("content-type", "text/html")
+        request.write(b'<script src="/error.js"></script>')
+        request.finish()
+
+    server.set_route("/error.js", handle_error_js)
+    server.set_route("/error.html", handle_error_html)
+
+    with context.expect_event("weberror") as error_info:
+        page.goto(server.PREFIX + "/error.html")
+    web_error = error_info.value
+    location = web_error.location
+    assert location["url"] == f"{server.PREFIX}/error.js"
+    assert location["line"] == 2
+    assert location["column"] > 0
+
+
+def test_pageload_event_should_work(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    with context.expect_event("pageload") as info:
+        page.goto(server.EMPTY_PAGE)
+    assert info.value == page
+
+
+def test_framenavigated_event_should_work(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    with context.expect_event("framenavigated") as info:
+        page.goto(server.EMPTY_PAGE)
+    frame = info.value
+    assert frame == page.main_frame
+    assert frame.url == server.EMPTY_PAGE
+
+
+def test_pageclose_event_should_work(context: BrowserContext) -> None:
+    page = context.new_page()
+    with context.expect_event("pageclose") as info:
+        page.close()
+    assert info.value == page
+
+
+def test_frameattached_event_should_work(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    with context.expect_event("frameattached") as info:
+        page.evaluate(
+            """() => {
+                const iframe = document.createElement('iframe');
+                iframe.src = 'about:blank';
+                document.body.appendChild(iframe);
+            }"""
+        )
+    assert info.value.parent_frame == page.main_frame
+
+
+def test_framedetached_event_should_work(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.evaluate(
+        """() => {
+            const iframe = document.createElement('iframe');
+            iframe.id = 'x';
+            iframe.src = 'about:blank';
+            document.body.appendChild(iframe);
+        }"""
+    )
+    page.wait_for_selector("iframe")
+    with context.expect_event("framedetached") as info:
+        page.evaluate("() => document.getElementById('x').remove()")
+    assert info.value.parent_frame == page.main_frame
+
+
+def test_download_event_should_work(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    def handle_download(request: TestServerRequest) -> None:
+        request.setHeader("Content-Type", "application/octet-stream")
+        request.setHeader("Content-Disposition", "attachment; filename=file.txt")
+        request.write(b"Hello world")
+        request.finish()
+
+    server.set_route("/download", handle_download)
+    page.set_content(f'<a href="{server.PREFIX}/download">download</a>')
+    with context.expect_event("download") as info:
+        page.click("a")
+    download = info.value
+    assert download.suggested_filename == "file.txt"
+    assert download.page == page
diff --git a/tests/sync/test_browsercontext_request_fallback.py b/tests/sync/test_browsercontext_request_fallback.py
new file mode 100644
index 000000000..6feb19942
--- /dev/null
+++ b/tests/sync/test_browsercontext_request_fallback.py
@@ -0,0 +1,359 @@
+# 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.
+
+from typing import Any, Callable, List
+
+import pytest
+
+from playwright.sync_api import BrowserContext, Error, Page, Request, Route
+from tests.server import Server
+
+
+def _append_with_return_value(values: List, value: Any) -> Any:
+    values.append(value)
+
+
+def test_should_work(page: Page, context: BrowserContext, server: Server) -> None:
+    context.route("**/*", lambda route: route.fallback())
+    page.goto(server.EMPTY_PAGE)
+
+
+def test_should_fall_back(page: Page, context: BrowserContext, server: Server) -> None:
+    intercepted: List[int] = []
+    context.route(
+        "**/empty.html",
+        lambda route: (
+            _append_with_return_value(intercepted, 1),
+            route.fallback(),
+        ),
+    )
+    context.route(
+        "**/empty.html",
+        lambda route: (
+            _append_with_return_value(intercepted, 2),
+            route.fallback(),
+        ),
+    )
+    context.route(
+        "**/empty.html",
+        lambda route: (
+            _append_with_return_value(intercepted, 3),
+            route.fallback(),
+        ),
+    )
+
+    page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+def test_should_fall_back_async_delayed(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    intercepted = []
+
+    def create_handler(i: int) -> Callable[[Route], None]:
+        def handler(route: Route) -> None:
+            intercepted.append(i)
+            page.wait_for_timeout(500)
+            route.fallback()
+
+        return handler
+
+    context.route("**/empty.html", create_handler(1))
+    context.route("**/empty.html", create_handler(2))
+    context.route("**/empty.html", create_handler(3))
+    page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+def test_should_chain_once(page: Page, context: BrowserContext, server: Server) -> None:
+    context.route(
+        "**/madeup.txt",
+        lambda route: route.fulfill(status=200, body="fulfilled one"),
+        times=1,
+    )
+    context.route("**/madeup.txt", lambda route: route.fallback(), times=1)
+
+    resp = page.goto(server.PREFIX + "/madeup.txt")
+    assert resp
+    body = resp.body()
+    assert body == b"fulfilled one"
+
+
+def test_should_not_chain_fulfill(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    failed = [False]
+
+    def handler(route: Route) -> None:
+        failed[0] = True
+
+    context.route("**/empty.html", handler)
+    context.route(
+        "**/empty.html",
+        lambda route: route.fulfill(status=200, body="fulfilled"),
+    )
+    context.route("**/empty.html", lambda route: route.fallback())
+
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    body = response.body()
+    assert body == b"fulfilled"
+    assert not failed[0]
+
+
+def test_should_not_chain_abort(
+    page: Page,
+    context: BrowserContext,
+    server: Server,
+    is_webkit: bool,
+    is_firefox: bool,
+) -> None:
+    failed = [False]
+
+    def handler(route: Route) -> None:
+        failed[0] = True
+
+    context.route("**/empty.html", handler)
+    context.route("**/empty.html", lambda route: route.abort())
+    context.route("**/empty.html", lambda route: route.fallback())
+
+    with pytest.raises(Error) as excinfo:
+        page.goto(server.EMPTY_PAGE)
+    if is_webkit:
+        assert "Blocked by Web Inspector" in excinfo.value.message
+    elif is_firefox:
+        assert "NS_ERROR_FAILURE" in excinfo.value.message
+    else:
+        assert "net::ERR_FAILED" in excinfo.value.message
+    assert not failed[0]
+
+
+def test_should_fall_back_after_exception(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    context.route("**/empty.html", lambda route: route.continue_())
+
+    def handler(route: Route) -> None:
+        try:
+            route.fulfill(response=47)  # type: ignore
+        except Exception:
+            route.fallback()
+
+    context.route("**/empty.html", handler)
+
+    page.goto(server.EMPTY_PAGE)
+
+
+def test_should_amend_http_headers(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    values = []
+
+    def handler(route: Route) -> None:
+        values.append(route.request.headers.get("foo"))
+        values.append(route.request.header_value("FOO"))
+        route.continue_()
+
+    context.route("**/sleep.zzz", handler)
+
+    def handler_with_header_mods(route: Route) -> None:
+        route.fallback(headers={**route.request.headers, "FOO": "bar"})
+
+    context.route("**/*", handler_with_header_mods)
+
+    page.goto(server.EMPTY_PAGE)
+    with server.expect_request("/sleep.zzz") as server_request_info:
+        page.evaluate("() => fetch('/sleep.zzz')")
+    values.append(server_request_info.value.getHeader("foo"))
+    assert values == ["bar", "bar", "bar"]
+
+
+def test_should_delete_header_with_undefined_value(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    server.set_route(
+        "/something",
+        lambda r: (
+            r.setHeader("Acces-Control-Allow-Origin", "*"),
+            r.write(b"done"),
+            r.finish(),
+        ),
+    )
+
+    intercepted_request = []
+
+    def capture_and_continue(route: Route, request: Request) -> None:
+        intercepted_request.append(request)
+        route.continue_()
+
+    context.route("**/*", capture_and_continue)
+
+    def delete_foo_header(route: Route, request: Request) -> None:
+        headers = request.all_headers()
+        del headers["foo"]
+        route.fallback(headers=headers)
+
+    context.route(server.PREFIX + "/something", delete_foo_header)
+    with server.expect_request("/something") as server_req_info:
+        text = page.evaluate(
+            """
+            async url => {
+                const data = await fetch(url, {
+                    headers: {
+                    foo: 'a',
+                    bar: 'b',
+                    }
+                });
+                return data.text();
+                }
+            """,
+            server.PREFIX + "/something",
+        )
+    server_req = server_req_info.value
+    assert text == "done"
+    assert not intercepted_request[0].headers.get("foo")
+    assert intercepted_request[0].headers.get("bar") == "b"
+    assert not server_req.getHeader("foo")
+    assert server_req.getHeader("bar") == "b"
+
+
+def test_should_amend_method(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    method: List[str] = []
+    context.route(
+        "**/*",
+        lambda route: (
+            _append_with_return_value(method, route.request.method),
+            route.continue_(),
+        ),
+    )
+    context.route("**/*", lambda route: route.fallback(method="POST"))
+
+    with server.expect_request("/sleep.zzz") as request_info:
+        page.evaluate("() => fetch('/sleep.zzz')")
+    request = request_info.value
+    assert method == ["POST"]
+    assert request.method == b"POST"
+
+
+def test_should_override_request_url(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    url: List[str] = []
+    context.route(
+        "**/global-var.html",
+        lambda route: (
+            _append_with_return_value(url, route.request.url),
+            route.continue_(),
+        ),
+    )
+    context.route(
+        "**/foo",
+        lambda route: route.fallback(url=server.PREFIX + "/global-var.html"),
+    )
+
+    with server.expect_request("/global-var.html") as server_request_info:
+        with page.expect_event("response") as response_info:
+            page.goto(server.PREFIX + "/foo")
+    server_request = server_request_info.value
+    response = response_info.value
+    assert url == [server.PREFIX + "/global-var.html"]
+    assert response.url == server.PREFIX + "/global-var.html"
+    assert response.request.url == server.PREFIX + "/global-var.html"
+    assert page.evaluate("() => window['globalVar']") == 123
+    assert server_request.uri == b"/global-var.html"
+    assert server_request.method == b"GET"
+
+
+def test_should_amend_post_data(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    post_data: List[str] = []
+    context.route(
+        "**/*",
+        lambda route: (
+            _append_with_return_value(post_data, route.request.post_data),
+            route.continue_(),
+        ),
+    )
+    context.route("**/*", lambda route: route.fallback(post_data="doggo"))
+
+    with server.expect_request("/sleep.zzz") as server_request_info:
+        page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })")
+    server_request = server_request_info.value
+    assert post_data == ["doggo"]
+    assert server_request.post_body == b"doggo"
+
+
+def test_should_amend_binary_post_data(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    post_data_buffer: List[str] = []
+    context.route(
+        "**/*",
+        lambda route: (
+            _append_with_return_value(post_data_buffer, route.request.post_data),
+            route.continue_(),
+        ),
+    )
+    context.route(
+        "**/*", lambda route: route.fallback(post_data=b"\x00\x01\x02\x03\x04")
+    )
+
+    with server.expect_request("/sleep.zzz") as server_request_info:
+        page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })")
+    server_request = server_request_info.value
+    # FIXME: should this be bytes?
+    assert post_data_buffer == ["\x00\x01\x02\x03\x04"]
+    assert server_request.method == b"POST"
+    assert server_request.post_body == b"\x00\x01\x02\x03\x04"
+
+
+def test_should_chain_fallback_into_page(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    intercepted: List[int] = []
+    context.route(
+        "**/empty.html",
+        lambda route: (_append_with_return_value(intercepted, 1), route.fallback()),
+    )
+    context.route(
+        "**/empty.html",
+        lambda route: (_append_with_return_value(intercepted, 2), route.fallback()),
+    )
+    context.route(
+        "**/empty.html",
+        lambda route: (_append_with_return_value(intercepted, 3), route.fallback()),
+    )
+    page.route(
+        "**/empty.html",
+        lambda route: (_append_with_return_value(intercepted, 4), route.fallback()),
+    )
+    page.route(
+        "**/empty.html",
+        lambda route: (_append_with_return_value(intercepted, 5), route.fallback()),
+    )
+    page.route(
+        "**/empty.html",
+        lambda route: (_append_with_return_value(intercepted, 6), route.fallback()),
+    )
+
+    page.goto(server.EMPTY_PAGE)
+    assert intercepted == [6, 5, 4, 3, 2, 1]
diff --git a/tests/sync/test_browsercontext_request_intercept.py b/tests/sync/test_browsercontext_request_intercept.py
new file mode 100644
index 000000000..16cca8cfd
--- /dev/null
+++ b/tests/sync/test_browsercontext_request_intercept.py
@@ -0,0 +1,136 @@
+# 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.
+
+from pathlib import Path
+
+import pytest
+from twisted.web import http
+
+from playwright.sync_api import BrowserContext, Page, Route
+from tests.server import Server
+
+
+def test_should_fulfill_intercepted_response(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    def handle(route: Route) -> None:
+        response = page.request.fetch(route.request)
+        route.fulfill(
+            response=response,
+            status=201,
+            headers={"foo": "bar"},
+            content_type="text/plain",
+            body="Yo, page!",
+        )
+
+    context.route("**/*", handle)
+    response = page.goto(server.PREFIX + "/empty.html")
+    assert response
+    assert response.status == 201
+    assert response.headers["foo"] == "bar"
+    assert response.headers["content-type"] == "text/plain"
+    assert page.evaluate("() => document.body.textContent") == "Yo, page!"
+
+
+def test_should_fulfill_response_with_empty_body(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    def handle(route: Route) -> None:
+        response = page.request.fetch(route.request)
+        route.fulfill(
+            response=response, status=201, body="", headers={"content-length": "0"}
+        )
+
+    context.route("**/*", handle)
+    response = page.goto(server.PREFIX + "/title.html")
+    assert response
+    assert response.status == 201
+    assert response.text() == ""
+
+
+def test_should_override_with_defaults_when_intercepted_response_not_provided(
+    page: Page, context: BrowserContext, server: Server, browser_name: str
+) -> None:
+    def server_handler(request: http.Request) -> None:
+        request.setHeader("foo", "bar")
+        request.write("my content".encode())
+        request.finish()
+
+    server.set_route("/empty.html", server_handler)
+
+    def handle(route: Route) -> None:
+        page.request.fetch(route.request)
+        route.fulfill(status=201)
+
+    context.route("**/*", handle)
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 201
+    assert response.text() == ""
+    if browser_name == "webkit":
+        assert response.headers == {"content-type": "text/plain"}
+    else:
+        assert response.headers == {}
+
+
+def test_should_fulfill_with_any_response(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    def server_handler(request: http.Request) -> None:
+        request.setHeader("foo", "bar")
+        request.write("Woo-hoo".encode())
+        request.finish()
+
+    server.set_route("/sample", server_handler)
+    sample_response = page.request.get(server.PREFIX + "/sample")
+    context.route(
+        "**/*",
+        lambda route: route.fulfill(
+            response=sample_response, status=201, content_type="text/plain"
+        ),
+    )
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 201
+    assert response.text() == "Woo-hoo"
+    assert response.headers["foo"] == "bar"
+
+
+def test_should_support_fulfill_after_intercept(
+    page: Page, context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    def handle_route(route: Route) -> None:
+        response = page.request.fetch(route.request)
+        route.fulfill(response=response)
+
+    context.route("**", handle_route)
+    with server.expect_request("/title.html") as request_info:
+        response = page.goto(server.PREFIX + "/title.html")
+    assert response
+    request = request_info.value
+    assert request.uri.decode() == "/title.html"
+    original = (assetdir / "title.html").read_text()
+    assert response.text() == original
+
+
+def test_should_show_exception_after_fulfill(page: Page, server: Server) -> None:
+    def _handle(route: Route) -> None:
+        route.continue_()
+        raise Exception("Exception text!?")
+
+    page.route("*/**", _handle)
+    page.goto(server.EMPTY_PAGE)
+    # Any next API call should throw because handler did throw during previous goto()
+    with pytest.raises(Exception, match="Exception text!?"):
+        page.goto(server.EMPTY_PAGE)
diff --git a/tests/sync/test_browsercontext_service_worker_policy.py b/tests/sync/test_browsercontext_service_worker_policy.py
new file mode 100644
index 000000000..190bdfbd5
--- /dev/null
+++ b/tests/sync/test_browsercontext_service_worker_policy.py
@@ -0,0 +1,37 @@
+# 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.
+from playwright.sync_api import Browser
+from tests.server import Server
+
+
+def test_should_allow_service_workers_by_default(
+    browser: Browser, server: Server
+) -> None:
+    context = browser.new_context()
+    page = context.new_page()
+    page.goto(server.PREFIX + "/serviceworkers/fetchdummy/sw.html")
+    page.evaluate("() => window.activationPromise")
+    context.close()
+
+
+def test_block_blocks_service_worker_registration(
+    browser: Browser, server: Server
+) -> None:
+    context = browser.new_context(service_workers="block")
+    page = context.new_page()
+    with page.expect_console_message(
+        lambda m: "Service Worker registration blocked by Playwright" == m.text
+    ):
+        page.goto(server.PREFIX + "/serviceworkers/fetchdummy/sw.html")
+    context.close()
diff --git a/tests/sync/test_browsercontext_storage_state.py b/tests/sync/test_browsercontext_storage_state.py
index 5c03e11b0..6850de8a1 100644
--- a/tests/sync/test_browsercontext_storage_state.py
+++ b/tests/sync/test_browsercontext_storage_state.py
@@ -13,13 +13,13 @@
 # limitations under the License.
 
 import json
+from pathlib import Path
 
-import pytest
+from playwright.sync_api import Browser, BrowserContext, Page, StorageState
+from tests.server import Server
 
 
-def test_should_capture_local_storage(context, is_webkit, is_win):
-    if is_webkit and is_win:
-        pytest.skip()
+def test_should_capture_local_storage(context: BrowserContext) -> None:
     page1 = context.new_page()
     page1.route("**/*", lambda route: route.fulfill(body="<html></html>"))
     page1.goto("https://www.example.com")
@@ -29,40 +29,72 @@ def test_should_capture_local_storage(context, is_webkit, is_win):
 
     state = context.storage_state()
     origins = state["origins"]
+    assert origins
     assert len(origins) == 2
     assert origins[0] == {
-        "origin": "https://www.example.com",
-        "localStorage": [{"name": "name1", "value": "value1"}],
-    }
-    assert origins[1] == {
         "origin": "https://www.domain.com",
         "localStorage": [{"name": "name2", "value": "value2"}],
     }
+    assert origins[1] == {
+        "origin": "https://www.example.com",
+        "localStorage": [{"name": "name1", "value": "value1"}],
+    }
 
 
-def test_should_set_local_storage(browser, is_webkit, is_win):
-    if is_webkit and is_win:
-        pytest.skip()
-    context = browser.new_context(
-        storage_state={
-            "origins": [
+def test_should_set_local_storage(browser: Browser) -> None:
+    storage_state: StorageState = {
+        "origins": [
+            {
+                "origin": "https://www.example.com",
+                "localStorage": [{"name": "name1", "value": "value1"}],
+            }
+        ]
+    }
+    # We intentionally hide the indexed_db part in our API for now
+    storage_state["origins"][0]["indexedDB"] = [  # type: ignore
+        {
+            "name": "db",
+            "version": 42,
+            "stores": [
                 {
-                    "origin": "https://www.example.com",
-                    "localStorage": [{"name": "name1", "value": "value1"}],
+                    "name": "store",
+                    "autoIncrement": False,
+                    "records": [{"key": "bar", "value": "foo"}],
+                    "indexes": [],
                 }
-            ]
+            ],
         }
-    )
+    ]
+    context = browser.new_context(storage_state=storage_state)
 
     page = context.new_page()
     page.route("**/*", lambda route: route.fulfill(body="<html></html>"))
     page.goto("https://www.example.com")
     local_storage = page.evaluate("window.localStorage")
     assert local_storage == {"name1": "value1"}
+
+    indexed_db = page.evaluate(
+        """async () => {
+        return new Promise((resolve, reject) => {
+            const openRequest = indexedDB.open('db', 42);
+            openRequest.addEventListener('success', () => {
+                const db = openRequest.result;
+                const transaction = db.transaction('store', 'readonly');
+                const getRequest = transaction.objectStore('store').get('bar');
+                getRequest.addEventListener('success', () => resolve(getRequest.result));
+                getRequest.addEventListener('error', () => reject(getRequest.error));
+            });
+            openRequest.addEventListener('error', () => reject(openRequest.error));
+        });
+    }"""
+    )
+    assert indexed_db == "foo"
     context.close()
 
 
-def test_should_round_trip_through_the_file(browser, context, tmpdir):
+def test_should_round_trip_through_the_file(
+    browser: Browser, context: BrowserContext, tmp_path: Path
+) -> None:
     page1 = context.new_page()
     page1.route(
         "**/*",
@@ -77,7 +109,7 @@ def test_should_round_trip_through_the_file(browser, context, tmpdir):
         }"""
     )
 
-    path = tmpdir / "storage-state.json"
+    path = tmp_path / "storage-state.json"
     state = context.storage_state(path=path)
     with open(path, "r") as f:
         written = json.load(f)
@@ -95,3 +127,48 @@ def test_should_round_trip_through_the_file(browser, context, tmpdir):
     cookie = page2.evaluate("document.cookie")
     assert cookie == "username=John Doe"
     context2.close()
+
+
+def test_should_serialise_indexed_db(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.evaluate(
+        """async () => {
+            await new Promise((resolve, reject) => {
+                const openRequest = indexedDB.open('db', 42);
+                openRequest.onupgradeneeded = () => {
+                openRequest.result.createObjectStore('store');
+                };
+                openRequest.onsuccess = () => {
+                const request = openRequest.result.transaction('store', 'readwrite')
+                    .objectStore('store')
+                    .put('foo', 'bar');
+                request.addEventListener('success', resolve);
+                request.addEventListener('error', reject);
+                };
+            });
+        }"""
+    )
+    assert page.context.storage_state() == {"cookies": [], "origins": []}
+    assert page.context.storage_state(indexed_db=True) == {
+        "cookies": [],
+        "origins": [
+            {
+                "origin": f"http://localhost:{server.PORT}",
+                "localStorage": [],
+                "indexedDB": [
+                    {
+                        "name": "db",
+                        "version": 42,
+                        "stores": [
+                            {
+                                "name": "store",
+                                "autoIncrement": False,
+                                "records": [{"key": "bar", "value": "foo"}],
+                                "indexes": [],
+                            }
+                        ],
+                    }
+                ],
+            }
+        ],
+    }
diff --git a/tests/sync/test_browsertype_connect.py b/tests/sync/test_browsertype_connect.py
new file mode 100644
index 000000000..74970c545
--- /dev/null
+++ b/tests/sync/test_browsertype_connect.py
@@ -0,0 +1,251 @@
+# 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 os
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+import pytest
+
+from playwright.sync_api import BrowserType, Error, Playwright, Route
+from tests.conftest import RemoteServer
+from tests.server import Server
+
+
+def test_browser_type_connect_slow_mo(
+    server: Server, browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser = browser_type.connect(remote_server.ws_endpoint, slow_mo=100)
+    browser_context = browser.new_context()
+    t1 = time.monotonic()
+    page = browser_context.new_page()
+    assert page.evaluate("11 * 11") == 121
+    assert (time.monotonic() - t1) >= 0.2
+    page.goto(server.EMPTY_PAGE)
+    browser.close()
+
+
+def test_browser_type_connect_should_be_able_to_reconnect_to_a_browser(
+    server: Server, browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser = browser_type.connect(remote_server.ws_endpoint)
+    browser_context = browser.new_context()
+    assert len(browser_context.pages) == 0
+    page = browser_context.new_page()
+    assert len(browser_context.pages) == 1
+    assert page.evaluate("11 * 11") == 121
+    page.goto(server.EMPTY_PAGE)
+    browser.close()
+
+    browser = browser_type.connect(remote_server.ws_endpoint)
+    browser_context = browser.new_context()
+    page = browser_context.new_page()
+    page.goto(server.EMPTY_PAGE)
+    browser.close()
+
+
+def test_browser_type_connect_should_be_able_to_connect_two_browsers_at_the_same_time(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser1 = browser_type.connect(remote_server.ws_endpoint)
+    assert len(browser1.contexts) == 0
+    browser1.new_context()
+    assert len(browser1.contexts) == 1
+
+    browser2 = browser_type.connect(remote_server.ws_endpoint)
+    assert len(browser2.contexts) == 0
+    browser2.new_context()
+    assert len(browser2.contexts) == 1
+    assert len(browser1.contexts) == 1
+
+    browser1.close()
+    page2 = browser2.new_page()
+    # original browser should still work
+    assert page2.evaluate("7 * 6") == 42
+
+    browser2.close()
+
+
+def test_browser_type_connect_disconnected_event_should_be_emitted_when_browser_is_closed_or_server_is_closed(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    # Launch another server to not affect other tests.
+    remote = launch_server()
+
+    browser1 = browser_type.connect(remote.ws_endpoint)
+    browser2 = browser_type.connect(remote.ws_endpoint)
+
+    disconnected1 = []
+    disconnected2 = []
+    browser1.on("disconnected", lambda browser: disconnected1.append(True))
+    browser2.on("disconnected", lambda browser: disconnected2.append(True))
+
+    page2 = browser2.new_page()
+
+    browser1.close()
+    assert len(disconnected1) == 1
+    assert len(disconnected2) == 0
+
+    remote.kill()
+    assert len(disconnected1) == 1
+
+    with pytest.raises(Error):
+        # Tickle connection so that it gets a chance to dispatch disconnect event.
+        page2.title()
+    assert len(disconnected2) == 1
+
+
+def test_browser_type_disconnected_event_should_have_browser_as_argument(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser = browser_type.connect(remote_server.ws_endpoint)
+    event_payloads = []
+    browser.on("disconnected", lambda b: event_payloads.append(b))
+    browser.close()
+    assert event_payloads[0] == browser
+
+
+def test_browser_type_connect_set_browser_connected_state(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser = browser_type.connect(remote_server.ws_endpoint)
+    assert browser.is_connected()
+    browser.close()
+    assert browser.is_connected() is False
+
+
+def test_browser_type_connect_should_throw_when_used_after_is_connected_returns_false(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    browser = browser_type.connect(remote_server.ws_endpoint)
+    page = browser.new_page()
+
+    remote_server.kill()
+
+    with pytest.raises(Error) as exc_info:
+        page.evaluate("1 + 1")
+    assert "has been closed" in exc_info.value.message
+    assert browser.is_connected() is False
+
+
+def test_browser_type_connect_should_forward_close_events_to_pages(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    # Launch another server to not affect other tests.
+    remote = launch_server()
+
+    browser = browser_type.connect(remote.ws_endpoint)
+    context = browser.new_context()
+    page = context.new_page()
+
+    events = []
+    browser.on("disconnected", lambda browser: events.append("browser::disconnected"))
+    context.on("close", lambda context: events.append("context::close"))
+    page.on("close", lambda page: events.append("page::close"))
+
+    browser.close()
+    assert events == ["page::close", "context::close", "browser::disconnected"]
+    remote.kill()
+    assert events == ["page::close", "context::close", "browser::disconnected"]
+
+
+def test_browser_type_connect_should_forward_close_events_on_remote_kill(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    # Launch another server to not affect other tests.
+    remote = launch_server()
+
+    browser = browser_type.connect(remote.ws_endpoint)
+    context = browser.new_context()
+    page = context.new_page()
+
+    events = []
+    browser.on("disconnected", lambda context: events.append("browser::disconnected"))
+    context.on("close", lambda context: events.append("context::close"))
+    page.on("close", lambda page: events.append("page::close"))
+    remote.kill()
+    with pytest.raises(Error):
+        page.title()
+    assert events == ["page::close", "context::close", "browser::disconnected"]
+
+
+def test_connect_to_closed_server_without_hangs(
+    browser_type: BrowserType, launch_server: Callable[[], RemoteServer]
+) -> None:
+    remote_server = launch_server()
+    remote_server.kill()
+    with pytest.raises(Error) as exc:
+        browser_type.connect(remote_server.ws_endpoint)
+    assert "WebSocket error: " in exc.value.message
+
+
+def test_browser_type_connect_should_fulfill_with_global_fetch_result(
+    browser_type: BrowserType,
+    launch_server: Callable[[], RemoteServer],
+    playwright: Playwright,
+    server: Server,
+) -> None:
+    # Launch another server to not affect other tests.
+    remote = launch_server()
+
+    browser = browser_type.connect(remote.ws_endpoint)
+    context = browser.new_context()
+    page = context.new_page()
+
+    def handle_request(route: Route) -> None:
+        request = playwright.request.new_context()
+        response = request.get(server.PREFIX + "/simple.json")
+        return route.fulfill(response=response)
+
+    page.route("**/*", handle_request)
+
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 200
+    assert response.json() == {"foo": "bar"}
+
+    remote.kill()
+
+
+def test_set_input_files_should_preserve_last_modified_timestamp(
+    browser_type: BrowserType,
+    launch_server: Callable[[], RemoteServer],
+    assetdir: Path,
+) -> None:
+    # Launch another server to not affect other tests.
+    remote = launch_server()
+
+    browser = browser_type.connect(remote.ws_endpoint)
+    context = browser.new_context()
+    page = context.new_page()
+
+    page.set_content("<input type=file multiple=true/>")
+    input = page.locator("input")
+    files: Any = ["file-to-upload.txt", "file-to-upload-2.txt"]
+    input.set_input_files([assetdir / file for file in files])
+    assert input.evaluate("input => [...input.files].map(f => f.name)") == files
+    timestamps = input.evaluate("input => [...input.files].map(f => f.lastModified)")
+    expected_timestamps = [os.path.getmtime(assetdir / file) * 1000 for file in files]
+
+    # On Linux browser sometimes reduces the timestamp by 1ms: 1696272058110.0715  -> 1696272058109 or even
+    # rounds it to seconds in WebKit: 1696272058110 -> 1696272058000.
+    for i in range(len(timestamps)):
+        assert abs(timestamps[i] - expected_timestamps[i]) < 1000
diff --git a/tests/sync/test_browsertype_connect_cdp.py b/tests/sync/test_browsertype_connect_cdp.py
new file mode 100644
index 000000000..27be1ba8f
--- /dev/null
+++ b/tests/sync/test_browsertype_connect_cdp.py
@@ -0,0 +1,35 @@
+# 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.
+
+from typing import Dict
+
+import pytest
+
+from playwright.sync_api import BrowserType
+from tests.server import find_free_port
+
+pytestmark = pytest.mark.only_browser("chromium")
+
+
+def test_connect_to_an_existing_cdp_session(
+    launch_arguments: Dict, browser_type: BrowserType
+) -> None:
+    port = find_free_port()
+    browser_server = browser_type.launch(
+        **launch_arguments, args=[f"--remote-debugging-port={port}"]
+    )
+    cdp_browser = browser_type.connect_over_cdp(f"http://127.0.0.1:{port}")
+    assert len(cdp_browser.contexts) == 1
+    cdp_browser.close()
+    browser_server.close()
diff --git a/tests/sync/test_cdp_session.py b/tests/sync/test_cdp_session.py
new file mode 100644
index 000000000..ad4e1f8f2
--- /dev/null
+++ b/tests/sync/test_cdp_session.py
@@ -0,0 +1,80 @@
+# 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 pytest
+
+from playwright.sync_api import Browser, Error, Page
+from tests.server import Server
+from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
+
+
+@pytest.mark.only_browser("chromium")
+def test_should_work(page: Page) -> None:
+    client = page.context.new_cdp_session(page)
+    events = []
+    client.on("Runtime.consoleAPICalled", lambda params: events.append(params))
+    client.send("Runtime.enable")
+    result = client.send(
+        "Runtime.evaluate",
+        {"expression": "window.foo = 'bar'; console.log('log'); 'result'"},
+    )
+    assert result == {"result": {"type": "string", "value": "result"}}
+    foo = page.evaluate("() => window.foo")
+    assert foo == "bar"
+    assert events[0]["args"][0]["value"] == "log"
+
+
+@pytest.mark.only_browser("chromium")
+def test_should_receive_events(page: Page, server: Server) -> None:
+    client = page.context.new_cdp_session(page)
+    client.send("Network.enable")
+    events = []
+    client.on("Network.requestWillBeSent", lambda event: events.append(event))
+    page.goto(server.EMPTY_PAGE)
+    assert len(events) == 1
+
+
+@pytest.mark.only_browser("chromium")
+def test_should_be_able_to_detach_session(page: Page) -> None:
+    client = page.context.new_cdp_session(page)
+    client.send("Runtime.enable")
+    eval_response = client.send(
+        "Runtime.evaluate", {"expression": "1 + 2", "returnByValue": True}
+    )
+    assert eval_response["result"]["value"] == 3
+    client.detach()
+    with pytest.raises(Error) as exc_info:
+        client.send("Runtime.evaluate", {"expression": "3 + 1", "returnByValue": True})
+    assert TARGET_CLOSED_ERROR_MESSAGE in exc_info.value.message
+
+
+@pytest.mark.only_browser("chromium")
+def test_should_not_break_page_close(browser: Browser) -> None:
+    context = browser.new_context()
+    page = context.new_page()
+    session = page.context.new_cdp_session(page)
+    session.detach()
+    page.close()
+    context.close()
+
+
+@pytest.mark.only_browser("chromium")
+def test_should_detach_when_page_closes(browser: Browser) -> None:
+    context = browser.new_context()
+    page = context.new_page()
+    session = context.new_cdp_session(page)
+    page.close()
+    with pytest.raises(Error):
+        session.detach()
+    context.close()
diff --git a/tests/sync/test_check.py b/tests/sync/test_check.py
index cd2b28b3f..1394664f9 100644
--- a/tests/sync/test_check.py
+++ b/tests/sync/test_check.py
@@ -12,32 +12,34 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from playwright.sync_api import Page
 
-def test_check_the_box(page):
+
+def test_check_the_box(page: Page) -> None:
     page.set_content('<input id="checkbox" type="checkbox"></input>')
     page.check("input")
     assert page.evaluate("checkbox.checked")
 
 
-def test_not_check_the_checked_box(page):
+def test_not_check_the_checked_box(page: Page) -> None:
     page.set_content('<input id="checkbox" type="checkbox" checked></input>')
     page.check("input")
     assert page.evaluate("checkbox.checked")
 
 
-def test_uncheck_the_box(page):
+def test_uncheck_the_box(page: Page) -> None:
     page.set_content('<input id="checkbox" type="checkbox" checked></input>')
     page.uncheck("input")
     assert page.evaluate("checkbox.checked") is False
 
 
-def test_not_uncheck_the_unchecked_box(page):
+def test_not_uncheck_the_unchecked_box(page: Page) -> None:
     page.set_content('<input id="checkbox" type="checkbox"></input>')
     page.uncheck("input")
     assert page.evaluate("checkbox.checked") is False
 
 
-def test_check_the_box_by_label(page):
+def test_check_the_box_by_label(page: Page) -> None:
     page.set_content(
         '<label for="checkbox"><input id="checkbox" type="checkbox"></input></label>'
     )
@@ -45,7 +47,7 @@ def test_check_the_box_by_label(page):
     assert page.evaluate("checkbox.checked")
 
 
-def test_check_the_box_outside_label(page):
+def test_check_the_box_outside_label(page: Page) -> None:
     page.set_content(
         '<label for="checkbox">Text</label><div><input id="checkbox" type="checkbox"></input></div>'
     )
@@ -53,7 +55,7 @@ def test_check_the_box_outside_label(page):
     assert page.evaluate("checkbox.checked")
 
 
-def test_check_the_box_inside_label_without_id(page):
+def test_check_the_box_inside_label_without_id(page: Page) -> None:
     page.set_content(
         '<label>Text<span><input id="checkbox" type="checkbox"></input></span></label>'
     )
@@ -61,7 +63,7 @@ def test_check_the_box_inside_label_without_id(page):
     assert page.evaluate("checkbox.checked")
 
 
-def test_check_radio(page):
+def test_check_radio(page: Page) -> None:
     page.set_content(
         """
       <input type='radio'>one</input>
@@ -72,7 +74,7 @@ def test_check_radio(page):
     assert page.evaluate("two.checked")
 
 
-def test_check_the_box_by_aria_role(page):
+def test_check_the_box_by_aria_role(page: Page) -> None:
     page.set_content(
         """<div role='checkbox' id='checkbox'>CHECKBOX</div>
       <script>
diff --git a/tests/sync/test_console.py b/tests/sync/test_console.py
index 54342795d..8a1f3a8fb 100644
--- a/tests/sync/test_console.py
+++ b/tests/sync/test_console.py
@@ -14,32 +14,39 @@
 
 from typing import List
 
+import pytest
+
 from playwright.sync_api import ConsoleMessage, Page
+from tests.server import Server
 
 
-def test_console_should_work(page: Page, server):
+def test_console_should_work(page: Page, browser_name: str) -> None:
     messages: List[ConsoleMessage] = []
     page.once("console", lambda m: messages.append(m))
     with page.expect_console_message():
-        page.evaluate('() => console.log("hello", 5, {foo: "bar"})'),
+        page.evaluate('() => console.log("hello", 5, {foo: "bar"})')
     assert len(messages) == 1
     message = messages[0]
-    assert message.text == "hello 5 JSHandle@object"
-    assert str(message) == "hello 5 JSHandle@object"
+    if browser_name != "firefox":
+        assert message.text == "hello 5 {foo: bar}"
+        assert str(message) == "hello 5 {foo: bar}"
+    else:
+        assert message.text == "hello 5 JSHandle@object"
+        assert str(message) == "hello 5 JSHandle@object"
     assert message.type == "log"
     assert message.args[0].json_value() == "hello"
     assert message.args[1].json_value() == 5
     assert message.args[2].json_value() == {"foo": "bar"}
 
 
-def test_console_should_emit_same_log_twice(page, server):
+def test_console_should_emit_same_log_twice(page: Page) -> None:
     messages = []
     page.on("console", lambda m: messages.append(m.text))
     page.evaluate('() => { for (let i = 0; i < 2; ++i ) console.log("hello"); } ')
     assert messages == ["hello", "hello"]
 
 
-def test_console_should_use_text_for__str__(page):
+def test_console_should_use_text_for__str__(page: Page) -> None:
     messages = []
     page.on("console", lambda m: messages.append(m))
     page.evaluate('() => console.log("Hello world")')
@@ -47,7 +54,7 @@ def test_console_should_use_text_for__str__(page):
     assert str(messages[0]) == "Hello world"
 
 
-def test_console_should_work_for_different_console_api_calls(page, server):
+def test_console_should_work_for_different_console_api_calls(page: Page) -> None:
     messages = []
     page.on("console", lambda m: messages.append(m))
     # All console events will be reported before 'page.evaluate' is finished.
@@ -78,43 +85,58 @@ def test_console_should_work_for_different_console_api_calls(page, server):
         "calling console.dir",
         "calling console.warn",
         "calling console.error",
-        "JSHandle@promise",
+        "Promise",
     ]
 
 
-def test_console_should_not_fail_for_window_object(page: Page, server):
+def test_console_should_not_fail_for_window_object(
+    page: Page, browser_name: str
+) -> None:
     messages = []
     page.once("console", lambda m: messages.append(m))
     with page.expect_console_message():
         page.evaluate("() => console.error(window)")
     assert len(messages) == 1
-    assert messages[0].text == "JSHandle@object"
+    if browser_name != "firefox":
+        assert messages[0].text == "Window"
+    else:
+        assert messages[0].text == "JSHandle@object"
 
 
-def test_console_should_trigger_correct_Log(page, server):
+# Upstream issue https://bugs.webkit.org/show_bug.cgi?id=229515
+@pytest.mark.skip_browser("webkit")
+def test_console_should_trigger_correct_Log(page: Page, server: Server) -> None:
     page.goto("about:blank")
     with page.expect_console_message() as message:
-        page.evaluate("url => fetch(url).catch(e => {})", server.EMPTY_PAGE),
-    assert "Access-Control-Allow-Origin" in message.value.text
+        page.evaluate("url => fetch(url).catch(e => {})", server.EMPTY_PAGE)
+    assert (
+        "Access-Control-Allow-Origin" in message.value.text
+        or "CORS" in message.value.text
+    )
     assert message.value.type == "error"
 
 
-def test_console_should_have_location_for_console_api_calls(page, server):
+def test_console_should_have_location_for_console_api_calls(
+    page: Page, server: Server
+) -> None:
     page.goto(server.EMPTY_PAGE)
-    with page.expect_console_message() as message:
+    with page.expect_console_message() as message_info:
         page.goto(server.PREFIX + "/consolelog.html")
-    message = message.value
+    message = message_info.value
     assert message.text == "yellow"
     assert message.type == "log"
     location = message.location
     # Engines have different column notion.
-    assert location.url == server.PREFIX + "/consolelog.html"
-    assert location.line == 7
+    assert location["url"] == server.PREFIX + "/consolelog.html"
+    assert location["lineNumber"] == 7
+    # Added in 1.60: location now also exposes line/column aliases for parity with WebError.location.
+    assert location["line"] == 7
+    assert location["column"] == location["columnNumber"]
 
 
 def test_console_should_not_throw_when_there_are_console_messages_in_detached_iframes(
-    page: Page, server
-):
+    page: Page, server: Server
+) -> None:
     page.goto(server.EMPTY_PAGE)
     with page.expect_popup() as popup:
         page.evaluate(
diff --git a/tests/sync/test_context_manager.py b/tests/sync/test_context_manager.py
new file mode 100644
index 000000000..6074691e9
--- /dev/null
+++ b/tests/sync/test_context_manager.py
@@ -0,0 +1,36 @@
+# 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.
+
+from typing import Dict
+
+import pytest
+
+from playwright.sync_api import BrowserContext, BrowserType
+
+
+def test_context_managers(browser_type: BrowserType, launch_arguments: Dict) -> None:
+    with browser_type.launch(**launch_arguments) as browser:
+        with browser.new_context() as context:
+            with context.new_page():
+                assert len(context.pages) == 1
+            assert len(context.pages) == 0
+            assert len(browser.contexts) == 1
+        assert len(browser.contexts) == 0
+    assert not browser.is_connected()
+
+
+def test_context_managers_not_hang(context: BrowserContext) -> None:
+    with pytest.raises(Exception, match="Oops!"):
+        with context.new_page():
+            raise Exception("Oops!")
diff --git a/tests/sync/test_debugger.py b/tests/sync/test_debugger.py
new file mode 100644
index 000000000..c6be1ec89
--- /dev/null
+++ b/tests/sync/test_debugger.py
@@ -0,0 +1,20 @@
+# 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.
+
+from playwright.sync_api import BrowserContext
+
+
+def test_should_expose_debugger_property(context: BrowserContext) -> None:
+    assert context.debugger is context.debugger
+    assert context.debugger.paused_details is None
diff --git a/tests/sync/test_element_handle.py b/tests/sync/test_element_handle.py
new file mode 100644
index 000000000..c2faa4a6e
--- /dev/null
+++ b/tests/sync/test_element_handle.py
@@ -0,0 +1,671 @@
+# 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.
+
+from typing import Any, Dict
+
+import pytest
+
+from playwright.sync_api import Browser, Error, Page
+from tests.server import Server
+from tests.sync.utils import Utils
+
+
+def test_bounding_box(page: Page, server: Server) -> None:
+    page.set_viewport_size({"width": 500, "height": 500})
+    page.goto(server.PREFIX + "/grid.html")
+    element_handle = page.query_selector(".box:nth-of-type(13)")
+    assert element_handle
+    box = element_handle.bounding_box()
+    assert box == {"x": 100, "y": 50, "width": 50, "height": 50}
+
+
+def test_bounding_box_handle_nested_frames(page: Page, server: Server) -> None:
+    page.set_viewport_size({"width": 500, "height": 500})
+    page.goto(server.PREFIX + "/frames/nested-frames.html")
+    nested_frame = page.frame(name="dos")
+    assert nested_frame
+    element_handle = nested_frame.query_selector("div")
+    assert element_handle
+    box = element_handle.bounding_box()
+    assert box == {"x": 24, "y": 224, "width": 268, "height": 18}
+
+
+def test_bounding_box_return_null_for_invisible_elements(page: Page) -> None:
+    page.set_content('<div style="display:none">hi</div>')
+    element = page.query_selector("div")
+    assert element
+    assert element.bounding_box() is None
+
+
+def test_bounding_box_force_a_layout(page: Page) -> None:
+    page.set_viewport_size({"width": 500, "height": 500})
+    page.set_content('<div style="width: 100px; height: 100px">hello</div>')
+    element_handle = page.query_selector("div")
+    assert element_handle
+    page.evaluate('element => element.style.height = "200px"', element_handle)
+    box = element_handle.bounding_box()
+    assert box == {"x": 8, "y": 8, "width": 100, "height": 200}
+
+
+def test_bounding_box_with_SVG_nodes(page: Page) -> None:
+    page.set_content(
+        """<svg xmlns="http://www.w3.org/2000/svg" width="500" height="500">
+             <rect id="theRect" x="30" y="50" width="200" height="300"></rect>
+           </svg>"""
+    )
+    element = page.query_selector("#therect")
+    assert element
+    pw_bounding_box = element.bounding_box()
+    web_bounding_box = page.evaluate(
+        """e => {
+            rect = e.getBoundingClientRect()
+            return {x: rect.x, y: rect.y, width: rect.width, height: rect.height}
+        }""",
+        element,
+    )
+    assert pw_bounding_box == web_bounding_box
+
+
+@pytest.mark.skip_browser("firefox")
+def test_bounding_box_with_page_scale(browser: Browser, server: Server) -> None:
+    context = browser.new_context(
+        viewport={"width": 400, "height": 400}, is_mobile=True
+    )
+    page = context.new_page()
+    page.goto(server.PREFIX + "/input/button.html")
+    button = page.query_selector("button")
+    assert button
+    button.evaluate(
+        """button => {
+            document.body.style.margin = '0'
+            button.style.borderWidth = '0'
+            button.style.width = '200px'
+            button.style.height = '20px'
+            button.style.marginLeft = '17px'
+            button.style.marginTop = '23px'
+        }"""
+    )
+
+    box = button.bounding_box()
+    assert box
+    assert round(box["x"] * 100) == 17 * 100
+    assert round(box["y"] * 100) == 23 * 100
+    assert round(box["width"] * 100) == 200 * 100
+    assert round(box["height"] * 100) == 20 * 100
+    context.close()
+
+
+def test_bounding_box_when_inline_box_child_is_outside_of_viewport(page: Page) -> None:
+    page.set_content(
+        """
+            <style>
+            i {
+            position: absolute
+            top: -1000px
+            }
+            body {
+            margin: 0
+            font-size: 12px
+            }
+            </style>
+            <span><i>woof</i><b>doggo</b></span>
+        """
+    )
+    handle = page.query_selector("span")
+    assert handle
+    box = handle.bounding_box()
+    assert handle
+    web_bounding_box = handle.evaluate(
+        """e => {
+        rect = e.getBoundingClientRect();
+        return {x: rect.x, y: rect.y, width: rect.width, height: rect.height};
+    }"""
+    )
+
+    def roundbox(b: Any) -> Dict:
+        return {
+            "x": round(b["x"] * 100),
+            "y": round(b["y"] * 100),
+            "width": round(b["width"] * 100),
+            "height": round(b["height"] * 100),
+        }
+
+    assert roundbox(box) == roundbox(web_bounding_box)
+
+
+def test_content_frame(page: Page, server: Server, utils: Utils) -> None:
+    page.goto(server.EMPTY_PAGE)
+    utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
+    element_handle = page.query_selector("#frame1")
+    assert element_handle
+    frame = element_handle.content_frame()
+    assert frame == page.frames[1]
+
+
+def test_content_frame_for_non_iframes(
+    page: Page, server: Server, utils: Utils
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
+    frame = page.frames[1]
+    element_handle = frame.evaluate_handle("document.body").as_element()
+    assert element_handle
+    assert element_handle.content_frame() is None
+
+
+def test_content_frame_for_document_element(
+    page: Page, server: Server, utils: Utils
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
+    frame = page.frames[1]
+    element_handle = frame.evaluate_handle("document.documentElement").as_element()
+    assert element_handle
+    assert element_handle.content_frame() is None
+
+
+def test_owner_frame(page: Page, server: Server, utils: Utils) -> None:
+    page.goto(server.EMPTY_PAGE)
+    utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
+    frame = page.frames[1]
+    element_handle = frame.evaluate_handle("document.body").as_element()
+    assert element_handle
+    assert element_handle.owner_frame() == frame
+
+
+def test_owner_frame_for_cross_process_iframes(
+    page: Page, server: Server, utils: Utils
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    utils.attach_frame(page, "frame1", server.CROSS_PROCESS_PREFIX + "/empty.html")
+    frame = page.frames[1]
+    element_handle = frame.evaluate_handle("document.body").as_element()
+    assert element_handle
+    assert element_handle.owner_frame() == frame
+
+
+def test_owner_frame_for_document(page: Page, server: Server, utils: Utils) -> None:
+    page.goto(server.EMPTY_PAGE)
+    utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
+    frame = page.frames[1]
+    element_handle = frame.evaluate_handle("document").as_element()
+    assert element_handle
+    assert element_handle.owner_frame() == frame
+
+
+def test_owner_frame_for_iframe_elements(
+    page: Page, server: Server, utils: Utils
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
+    frame = page.main_frame
+    element_handle = frame.evaluate_handle(
+        'document.querySelector("#frame1")'
+    ).as_element()
+    assert element_handle
+    assert element_handle.owner_frame() == frame
+
+
+def test_owner_frame_for_cross_frame_evaluations(
+    page: Page, server: Server, utils: Utils
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    utils.attach_frame(page, "frame1", server.EMPTY_PAGE)
+    frame = page.main_frame
+    element_handle = frame.evaluate_handle(
+        'document.querySelector("#frame1").contentWindow.document.body'
+    ).as_element()
+    assert element_handle
+    assert element_handle.owner_frame() == frame.child_frames[0]
+
+
+def test_owner_frame_for_detached_elements(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    div_handle = page.evaluate_handle(
+        """() => {
+            div = document.createElement('div');
+            document.body.appendChild(div);
+            return div;
+        }"""
+    ).as_element()
+    assert div_handle
+
+    assert div_handle.owner_frame() == page.main_frame
+    page.evaluate(
+        """() => {
+            div = document.querySelector('div')
+            document.body.removeChild(div)
+        }"""
+    )
+    assert div_handle.owner_frame() == page.main_frame
+
+
+def test_click(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    button = page.query_selector("button")
+    assert button
+    button.click()
+    assert page.evaluate("result") == "Clicked"
+
+
+def test_click_with_node_removed(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    page.evaluate('delete window["Node"]')
+    button = page.query_selector("button")
+    assert button
+    button.click()
+    assert page.evaluate("result") == "Clicked"
+
+
+def test_click_for_shadow_dom_v1(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/shadow.html")
+    button_handle = page.evaluate_handle("button").as_element()
+    assert button_handle
+    button_handle.click()
+    assert page.evaluate("clicked")
+
+
+def test_click_for_TextNodes(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    buttonTextNode = page.evaluate_handle(
+        'document.querySelector("button").firstChild'
+    ).as_element()
+    assert buttonTextNode
+    buttonTextNode.click()
+    assert page.evaluate("result") == "Clicked"
+
+
+def test_click_throw_for_detached_nodes(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    button = page.query_selector("button")
+    assert button
+    page.evaluate("button => button.remove()", button)
+    with pytest.raises(Error) as exc_info:
+        button.click()
+    assert "Element is not attached to the DOM" in exc_info.value.message
+
+
+def test_click_throw_for_hidden_nodes_with_force(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    button = page.query_selector("button")
+    assert button
+    page.evaluate('button => button.style.display = "none"', button)
+    with pytest.raises(Error) as exc_info:
+        button.click(force=True)
+    assert "Element is not visible" in exc_info.value.message
+
+
+def test_click_throw_for_recursively_hidden_nodes_with_force(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    button = page.query_selector("button")
+    assert button
+    page.evaluate('button => button.parentElement.style.display = "none"', button)
+    with pytest.raises(Error) as exc_info:
+        button.click(force=True)
+    assert "Element is not visible" in exc_info.value.message
+
+
+def test_click_throw_for__br__elements_with_force(page: Page) -> None:
+    page.set_content("hello<br>goodbye")
+    br = page.query_selector("br")
+    assert br
+    with pytest.raises(Error) as exc_info:
+        br.click(force=True)
+    assert "Element is outside of the viewport" in exc_info.value.message
+
+
+def test_double_click_the_button(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    page.evaluate(
+        """() => {
+            window.double = false;
+            button = document.querySelector('button');
+            button.addEventListener('dblclick', event => {
+            window.double = true;
+            });
+        }"""
+    )
+    button = page.query_selector("button")
+    assert button
+    button.dblclick()
+    assert page.evaluate("double")
+    assert page.evaluate("result") == "Clicked"
+
+
+def test_hover(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/scrollable.html")
+    button = page.query_selector("#button-6")
+    assert button
+    button.hover()
+    assert page.evaluate('document.querySelector("button:hover").id') == "button-6"
+
+
+def test_hover_when_node_is_removed(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/scrollable.html")
+    page.evaluate('delete window["Node"]')
+    button = page.query_selector("#button-6")
+    assert button
+    button.hover()
+    assert page.evaluate('document.querySelector("button:hover").id') == "button-6"
+
+
+def test_scroll(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/offscreenbuttons.html")
+    for i in range(11):
+        button = page.query_selector(f"#btn{i}")
+        assert button
+        before = button.evaluate(
+            """button => {
+                return button.getBoundingClientRect().right - window.innerWidth
+            }"""
+        )
+
+        assert before == 10 * i
+        button.scroll_into_view_if_needed()
+        after = button.evaluate(
+            """button => {
+                return button.getBoundingClientRect().right - window.innerWidth
+            }"""
+        )
+
+        assert after <= 0
+        page.evaluate("() => window.scrollTo(0, 0)")
+
+
+def test_scroll_should_throw_for_detached_element(page: Page) -> None:
+    page.set_content("<div>Hello</div>")
+    div = page.query_selector("div")
+    assert div
+    div.evaluate("div => div.remove()")
+    with pytest.raises(Error) as exc_info:
+        div.scroll_into_view_if_needed()
+    assert "Element is not attached to the DOM" in exc_info.value.message
+
+
+def test_should_timeout_waiting_for_visible(page: Page) -> None:
+    page.set_content('<div style="display:none">Hello</div>')
+    div = page.query_selector("div")
+    assert div
+    with pytest.raises(Error) as exc_info:
+        div.scroll_into_view_if_needed(timeout=3000)
+    assert "element is not visible" in exc_info.value.message
+    assert "retrying scroll into view action" in exc_info.value.message
+
+
+def test_fill_input(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/textarea.html")
+    handle = page.query_selector("input")
+    assert handle
+    handle.fill("some value")
+    assert page.evaluate("result") == "some value"
+
+
+def test_fill_input_when_Node_is_removed(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/textarea.html")
+    page.evaluate('delete window["Node"]')
+    handle = page.query_selector("input")
+    assert handle
+    handle.fill("some value")
+    assert page.evaluate("result") == "some value"
+
+
+def test_select_textarea(
+    page: Page, server: Server, is_firefox: bool, is_webkit: bool
+) -> None:
+    page.goto(server.PREFIX + "/input/textarea.html")
+    textarea = page.query_selector("textarea")
+    assert textarea
+    textarea.evaluate('textarea => textarea.value = "some value"')
+    textarea.select_text()
+    if is_firefox or is_webkit:
+        assert textarea.evaluate("el => el.selectionStart") == 0
+        assert textarea.evaluate("el => el.selectionEnd") == 10
+    else:
+        assert page.evaluate("() => window.getSelection().toString()") == "some value"
+
+
+def test_select_input(
+    page: Page, server: Server, is_firefox: bool, is_webkit: bool
+) -> None:
+    page.goto(server.PREFIX + "/input/textarea.html")
+    input = page.query_selector("input")
+    assert input
+    input.evaluate('input => input.value = "some value"')
+    input.select_text()
+    if is_firefox or is_webkit:
+        assert input.evaluate("el => el.selectionStart") == 0
+        assert input.evaluate("el => el.selectionEnd") == 10
+    else:
+        assert page.evaluate("() => window.getSelection().toString()") == "some value"
+
+
+def test_select_text_select_plain_div(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/textarea.html")
+    div = page.query_selector("div.plain")
+    assert div
+    div.select_text()
+    assert page.evaluate("() => window.getSelection().toString()") == "Plain div"
+
+
+def test_select_text_timeout_waiting_for_invisible_element(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.PREFIX + "/input/textarea.html")
+    textarea = page.query_selector("textarea")
+    assert textarea
+    textarea.evaluate('e => e.style.display = "none"')
+    with pytest.raises(Error) as exc_info:
+        textarea.select_text(timeout=3000)
+    assert "element is not visible" in exc_info.value.message
+
+
+def test_a_nice_preview(page: Page, server: Server) -> None:
+    page.goto(f"{server.PREFIX}/dom.html")
+    outer = page.query_selector("#outer")
+    inner = page.query_selector("#inner")
+    assert inner
+    check = page.query_selector("#check")
+    text = inner.evaluate_handle("e => e.firstChild")
+    page.evaluate("1")  # Give them a chance to calculate the preview.
+    assert str(outer) == 'JSHandle@<div id="outer" name="value">…</div>'
+    assert str(inner) == 'JSHandle@<div id="inner">Text,↵more text</div>'
+    assert str(text) == "JSHandle@#text=Text,↵more text"
+    assert (
+        str(check) == 'JSHandle@<input checked id="check" foo="bar"" type="checkbox"/>'
+    )
+
+
+def test_get_attribute(page: Page, server: Server) -> None:
+    page.goto(f"{server.PREFIX}/dom.html")
+    handle = page.query_selector("#outer")
+    assert handle
+    assert handle.get_attribute("name") == "value"
+    assert page.get_attribute("#outer", "name") == "value"
+
+
+def test_inner_html(page: Page, server: Server) -> None:
+    page.goto(f"{server.PREFIX}/dom.html")
+    handle = page.query_selector("#outer")
+    assert handle
+    assert handle.inner_html() == '<div id="inner">Text,\nmore text</div>'
+    assert page.inner_html("#outer") == '<div id="inner">Text,\nmore text</div>'
+
+
+def test_inner_text(page: Page, server: Server) -> None:
+    page.goto(f"{server.PREFIX}/dom.html")
+    handle = page.query_selector("#inner")
+    assert handle
+    assert handle.inner_text() == "Text, more text"
+    assert page.inner_text("#inner") == "Text, more text"
+
+
+def test_inner_text_should_throw(page: Page) -> None:
+    page.set_content("<svg>text</svg>")
+    with pytest.raises(Error) as exc_info1:
+        page.inner_text("svg")
+    assert " Node is not an HTMLElement" in exc_info1.value.message
+
+    handle = page.query_selector("svg")
+    assert handle
+    with pytest.raises(Error) as exc_info2:
+        handle.inner_text()
+    assert " Node is not an HTMLElement" in exc_info2.value.message
+
+
+def test_text_content(page: Page, server: Server) -> None:
+    page.goto(f"{server.PREFIX}/dom.html")
+    handle = page.query_selector("#inner")
+    assert handle
+    assert handle.text_content() == "Text,\nmore text"
+    assert page.text_content("#inner") == "Text,\nmore text"
+
+
+def test_check_the_box(page: Page) -> None:
+    page.set_content('<input id="checkbox" type="checkbox"></input>')
+    input = page.query_selector("input")
+    assert input
+    input.check()
+    assert page.evaluate("checkbox.checked")
+
+
+def test_uncheck_the_box(page: Page) -> None:
+    page.set_content('<input id="checkbox" type="checkbox" checked></input>')
+    input = page.query_selector("input")
+    assert input
+    input.uncheck()
+    assert page.evaluate("checkbox.checked") is False
+
+
+def test_select_single_option(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    select = page.query_selector("select")
+    assert select
+    select.select_option(value="blue")
+    assert page.evaluate("result.onInput") == ["blue"]
+    assert page.evaluate("result.onChange") == ["blue"]
+
+
+def test_focus_a_button(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    button = page.query_selector("button")
+    assert button
+    assert button.evaluate("button => document.activeElement === button") is False
+    button.focus()
+    assert button.evaluate("button => document.activeElement === button")
+
+
+def test_is_visible_and_is_hidden_should_work(page: Page) -> None:
+    page.set_content("<div>Hi</div><span></span>")
+    div = page.query_selector("div")
+    assert div
+    assert div.is_visible()
+    assert div.is_hidden() is False
+    assert page.is_visible("div")
+    assert page.is_hidden("div") is False
+    span = page.query_selector("span")
+    assert span
+    assert span.is_visible() is False
+    assert span.is_hidden()
+    assert page.is_visible("span") is False
+    assert page.is_hidden("span")
+
+
+def test_is_enabled_and_is_disabled_should_work(page: Page) -> None:
+    page.set_content(
+        """
+        <button disabled>button1</button>
+        <button>button2</button>
+        <div>div</div>
+    """
+    )
+    div = page.query_selector("div")
+    assert div
+    assert div.is_enabled()
+    assert div.is_disabled() is False
+    assert page.is_enabled("div")
+    assert page.is_disabled("div") is False
+    button1 = page.query_selector(":text('button1')")
+    assert button1
+    assert button1.is_enabled() is False
+    assert button1.is_disabled()
+    assert page.is_enabled(":text('button1')") is False
+    assert page.is_disabled(":text('button1')")
+    button2 = page.query_selector(":text('button2')")
+    assert button2
+    assert button2.is_enabled()
+    assert button2.is_disabled() is False
+    assert page.is_enabled(":text('button2')")
+    assert page.is_disabled(":text('button2')") is False
+
+
+def test_is_editable_should_work(page: Page) -> None:
+    page.set_content("<input id=input1 disabled><textarea></textarea><input id=input2>")
+    page.eval_on_selector("textarea", "t => t.readOnly = true")
+    input1 = page.query_selector("#input1")
+    assert input1
+    assert input1.is_editable() is False
+    assert page.is_editable("#input1") is False
+    input2 = page.query_selector("#input2")
+    assert input2
+    assert input2.is_editable()
+    assert page.is_editable("#input2")
+    textarea = page.query_selector("textarea")
+    assert textarea
+    assert textarea.is_editable() is False
+    assert page.is_editable("textarea") is False
+
+
+def test_is_checked_should_work(page: Page) -> None:
+    page.set_content('<input type="checkbox" checked><div>Not a checkbox</div>')
+    handle = page.query_selector("input")
+    assert handle
+    assert handle.is_checked()
+    assert page.is_checked("input")
+    handle.evaluate("input => input.checked = false")
+    assert handle.is_checked() is False
+    assert page.is_checked("input") is False
+    with pytest.raises(Error) as exc_info:
+        page.is_checked("div")
+    assert "Not a checkbox or radio button" in exc_info.value.message
+
+
+def test_input_value(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/textarea.html")
+    element = page.query_selector("input")
+    assert element
+    element.fill("my-text-content")
+    assert element.input_value() == "my-text-content"
+
+    element.fill("")
+    assert element.input_value() == ""
+
+
+def test_set_checked(page: Page) -> None:
+    page.set_content("`<input id='checkbox' type='checkbox'></input>`")
+    input = page.query_selector("input")
+    assert input
+    input.set_checked(True)
+    assert page.evaluate("checkbox.checked")
+    input.set_checked(False)
+    assert page.evaluate("checkbox.checked") is False
+
+
+def test_should_allow_disposing_twice(page: Page) -> None:
+    page.set_content("<section>39</section>")
+    element = page.query_selector("section")
+    assert element
+    element.dispose()
+    element.dispose()
diff --git a/tests/sync/test_element_handle_wait_for_element_state.py b/tests/sync/test_element_handle_wait_for_element_state.py
new file mode 100644
index 000000000..8f1f2912c
--- /dev/null
+++ b/tests/sync/test_element_handle_wait_for_element_state.py
@@ -0,0 +1,119 @@
+# 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 pytest
+
+from playwright.sync_api import Error, Page
+
+
+def test_should_wait_for_visible(page: Page) -> None:
+    page.set_content('<div id=div style="display:none">content</div>')
+    div = page.query_selector("div")
+    assert div
+    page.evaluate('setTimeout(() => div.style.display = "block", 500)')
+    assert div.is_visible() is False
+    div.wait_for_element_state("visible")
+    assert div.is_visible()
+
+
+def test_should_wait_for_already_visible(page: Page) -> None:
+    page.set_content("<div>content</div>")
+    div = page.query_selector("div")
+    assert div
+    div.wait_for_element_state("visible")
+
+
+def test_should_timeout_waiting_for_visible(page: Page) -> None:
+    page.set_content('<div style="display:none">content</div>')
+    div = page.query_selector("div")
+    assert div
+    with pytest.raises(Error) as exc_info:
+        div.wait_for_element_state("visible", timeout=1000)
+    assert "Timeout 1000ms exceeded" in exc_info.value.message
+
+
+def test_should_throw_waiting_for_visible_when_detached(page: Page) -> None:
+    page.set_content('<div id=div style="display:none">content</div>')
+    div = page.query_selector("div")
+    assert div
+    page.evaluate("setTimeout(() => div.remove(), 500)")
+    with pytest.raises(Error) as exc_info:
+        div.wait_for_element_state("visible")
+    assert "Element is not attached to the DOM" in exc_info.value.message
+
+
+def test_should_wait_for_hidden(page: Page) -> None:
+    page.set_content("<div id=div>content</div>")
+    div = page.query_selector("div")
+    assert div
+    page.evaluate('setTimeout(() => div.style.display = "none", 500)')
+    assert div.is_hidden() is False
+    div.wait_for_element_state("hidden")
+    assert div.is_hidden()
+
+
+def test_should_wait_for_already_hidden(page: Page) -> None:
+    page.set_content("<div></div>")
+    div = page.query_selector("div")
+    assert div
+    div.wait_for_element_state("hidden")
+
+
+def test_should_wait_for_hidden_when_detached(page: Page) -> None:
+    page.set_content("<div id=div>content</div>")
+    div = page.query_selector("div")
+    assert div
+    page.evaluate("setTimeout(() => div.remove(), 500)")
+    div.wait_for_element_state("hidden")
+    assert div.is_hidden()
+
+
+def test_should_wait_for_enabled_button(page: Page) -> None:
+    page.set_content("<button id=button disabled><span>Target</span></button>")
+    span = page.query_selector("text=Target")
+    assert span
+    assert span.is_enabled() is False
+    page.evaluate("setTimeout(() => button.disabled = false, 500)")
+    span.wait_for_element_state("enabled")
+    assert span.is_enabled()
+
+
+def test_should_throw_waiting_for_enabled_when_detached(page: Page) -> None:
+    page.set_content("<button id=button disabled>Target</button>")
+    button = page.query_selector("button")
+    assert button
+    page.evaluate("setTimeout(() => button.remove(), 500)")
+    with pytest.raises(Error) as exc_info:
+        button.wait_for_element_state("enabled")
+    assert "Element is not attached to the DOM" in exc_info.value.message
+
+
+def test_should_wait_for_disabled_button(page: Page) -> None:
+    page.set_content("<button id=button><span>Target</span></button>")
+    span = page.query_selector("text=Target")
+    assert span
+    assert span.is_disabled() is False
+    page.evaluate("setTimeout(() => button.disabled = true, 500)")
+    span.wait_for_element_state("disabled")
+    assert span.is_disabled()
+
+
+def test_should_wait_for_editable_input(page: Page) -> None:
+    page.set_content("<input id=input readonly>")
+    input = page.query_selector("input")
+    assert input
+    page.evaluate("setTimeout(() => input.readOnly = false, 500)")
+    assert input.is_editable() is False
+    input.wait_for_element_state("editable")
+    assert input.is_editable()
diff --git a/tests/sync/test_expect_misc.py b/tests/sync/test_expect_misc.py
new file mode 100644
index 000000000..4d8b68cc0
--- /dev/null
+++ b/tests/sync/test_expect_misc.py
@@ -0,0 +1,72 @@
+# 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 pytest
+
+from playwright.sync_api import Page, expect
+from tests.server import Server
+
+
+def test_to_be_in_viewport_should_work(page: Page) -> None:
+    page.set_content(
+        """
+      <div id=big style="height: 10000px;"></div>
+      <div id=small>foo</div>
+    """
+    )
+    expect(page.locator("#big")).to_be_in_viewport()
+    expect(page.locator("#small")).not_to_be_in_viewport()
+    page.locator("#small").scroll_into_view_if_needed()
+    expect(page.locator("#small")).to_be_in_viewport()
+    expect(page.locator("#small")).to_be_in_viewport(ratio=1)
+
+
+def test_to_be_in_viewport_should_respect_ratio_option(
+    page: Page, server: Server
+) -> None:
+    page.set_content(
+        """
+      <style>body, div, html { padding: 0; margin: 0; }</style>
+      <div id=big style="height: 400vh;"></div>
+    """
+    )
+    expect(page.locator("div")).to_be_in_viewport()
+    expect(page.locator("div")).to_be_in_viewport(ratio=0.1)
+    expect(page.locator("div")).to_be_in_viewport(ratio=0.2)
+
+    expect(page.locator("div")).to_be_in_viewport(ratio=0.25)
+    # In this test, element's ratio is 0.25.
+    expect(page.locator("div")).not_to_be_in_viewport(ratio=0.26)
+
+    expect(page.locator("div")).not_to_be_in_viewport(ratio=0.3)
+    expect(page.locator("div")).not_to_be_in_viewport(ratio=0.7)
+    expect(page.locator("div")).not_to_be_in_viewport(ratio=0.8)
+
+
+def test_to_be_in_viewport_should_have_good_stack(page: Page, server: Server) -> None:
+    with pytest.raises(AssertionError) as exc_info:
+        expect(page.locator("body")).not_to_be_in_viewport(timeout=1000)
+    assert 'unexpected value "viewport ratio' in str(exc_info.value)
+
+
+def test_to_be_in_viewport_should_report_intersection_even_if_fully_covered_by_other_element(
+    page: Page, server: Server
+) -> None:
+    page.set_content(
+        """
+      <h1>hello</h1>
+      <div style="position: relative; height: 10000px; top: -5000px;></div>
+    """
+    )
+    expect(page.locator("h1")).to_be_in_viewport()
diff --git a/tests/sync/test_extension.py b/tests/sync/test_extension.py
new file mode 100644
index 000000000..2cb8aee77
--- /dev/null
+++ b/tests/sync/test_extension.py
@@ -0,0 +1,101 @@
+# 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.
+
+from pathlib import Path
+from typing import Any, Callable, Dict, Generator, List, Optional
+
+import pytest
+
+from playwright.sync_api import BrowserContext, BrowserType
+
+
+@pytest.fixture()
+def launch_persistent_context(
+    browser_type: BrowserType,
+    browser_channel: Optional[str],
+    tmp_path: Path,
+    launch_arguments: Dict[str, Any],
+    is_headless_shell: bool,
+) -> Generator[Callable[..., BrowserContext], None, None]:
+    if browser_channel and browser_channel.startswith("chrome"):
+        pytest.skip(
+            "--load-extension is not supported in Chrome anymore. https://groups.google.com/a/chromium.org/g/chromium-extensions/c/1-g8EFx2BBY/m/S0ET5wPjCAAJ"
+        )
+    if is_headless_shell:
+        pytest.skip("Headless Shell has no support for extensions")
+
+    contexts: List[BrowserContext] = []
+
+    def launch(extension_path: str, **kwargs: Any) -> BrowserContext:
+        context = browser_type.launch_persistent_context(
+            str(tmp_path),
+            **launch_arguments,
+            **kwargs,
+            args=[
+                f"--disable-extensions-except={extension_path}",
+                f"--load-extension={extension_path}",
+            ],
+        )
+        contexts.append(context)
+        return context
+
+    yield launch
+
+    for context in contexts:
+        context.close()
+
+
+@pytest.mark.only_browser("chromium")
+def test_should_give_access_to_the_service_worker(
+    launch_persistent_context: Callable[..., BrowserContext],
+    assetdir: Path,
+) -> None:
+    extension_path = str(assetdir / "extension-mv3-simple")
+    context = launch_persistent_context(extension_path)
+    service_workers = context.service_workers
+    service_worker = (
+        service_workers[0]
+        if len(service_workers)
+        else context.wait_for_event("serviceworker")
+    )
+    assert service_worker
+    assert service_worker in context.service_workers
+    while not service_worker.evaluate("globalThis.MAGIC") == 42:
+        context.pages[0].wait_for_timeout(100)
+    context.close()
+    assert len(context.background_pages) == 0
+
+
+@pytest.mark.only_browser("chromium")
+def test_should_give_access_to_the_service_worker_when_recording_video(
+    launch_persistent_context: Callable[..., BrowserContext],
+    tmp_path: Path,
+    assetdir: Path,
+) -> None:
+    extension_path = str(assetdir / "extension-mv3-simple")
+    context = launch_persistent_context(
+        extension_path, record_video_dir=(tmp_path / "videos")
+    )
+    service_workers = context.service_workers
+    service_worker = (
+        service_workers[0]
+        if len(service_workers)
+        else context.wait_for_event("serviceworker")
+    )
+    assert service_worker
+    assert service_worker in context.service_workers
+    while not service_worker.evaluate("globalThis.MAGIC") == 42:
+        context.pages[0].wait_for_timeout(100)
+    context.close()
+    assert len(context.background_pages) == 0
diff --git a/tests/sync/test_fetch_browser_context.py b/tests/sync/test_fetch_browser_context.py
new file mode 100644
index 000000000..affca0e0d
--- /dev/null
+++ b/tests/sync/test_fetch_browser_context.py
@@ -0,0 +1,340 @@
+# 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 json
+from pathlib import Path
+from typing import Any, Dict, List, cast
+from urllib.parse import parse_qs
+
+import pytest
+
+from playwright.sync_api import (
+    BrowserContext,
+    Error,
+    FilePayload,
+    FormData,
+    Page,
+)
+from tests.server import Server
+from tests.utils import must
+
+
+def test_get_should_work(context: BrowserContext, server: Server) -> None:
+    response = context.request.get(server.PREFIX + "/simple.json")
+    assert response.url == server.PREFIX + "/simple.json"
+    assert response.status == 200
+    assert response.status_text == "OK"
+    assert response.ok is True
+    assert response.headers["content-type"] == "application/json"
+    assert {
+        "name": "Content-Type",
+        "value": "application/json",
+    } in response.headers_array
+    assert response.text() == '{"foo": "bar"}\n'
+
+
+def test_fetch_should_work(context: BrowserContext, server: Server) -> None:
+    response = context.request.fetch(server.PREFIX + "/simple.json")
+    assert response.url == server.PREFIX + "/simple.json"
+    assert response.status == 200
+    assert response.status_text == "OK"
+    assert response.ok is True
+    assert response.headers["content-type"] == "application/json"
+    assert {
+        "name": "Content-Type",
+        "value": "application/json",
+    } in response.headers_array
+    assert response.text() == '{"foo": "bar"}\n'
+
+
+def test_should_throw_on_network_error(context: BrowserContext, server: Server) -> None:
+    server.set_route("/test", lambda request: request.loseConnection())
+    with pytest.raises(Error, match="socket hang up"):
+        context.request.fetch(server.PREFIX + "/test")
+
+
+def test_should_add_session_cookies_to_request(
+    context: BrowserContext, server: Server
+) -> None:
+    context.add_cookies(
+        [
+            {
+                "name": "username",
+                "value": "John Doe",
+                "url": server.EMPTY_PAGE,
+                "expires": -1,
+                "httpOnly": False,
+                "secure": False,
+                "sameSite": "Lax",
+            }
+        ]
+    )
+    with server.expect_request("/empty.html") as server_req:
+        context.request.get(server.EMPTY_PAGE)
+    assert server_req.value.getHeader("Cookie") == "username=John Doe"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+def test_should_support_query_params(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    expected_params = {"p1": "v1", "парам2": "знач2"}
+    with server.expect_request("/empty.html") as server_req:
+        getattr(context.request, method)(
+            server.EMPTY_PAGE + "?p1=foo", params=expected_params
+        )
+    assert list(map(lambda x: x.decode(), server_req.value.args["p1".encode()])) == [
+        "foo",
+        "v1",
+    ]
+    assert server_req.value.args["парам2".encode()][0].decode() == "знач2"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+def test_should_support_params_passed_as_object(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    params = {
+        "param1": "value1",
+        "парам2": "знач2",
+    }
+    with server.expect_request("/empty.html") as server_req:
+        getattr(context.request, method)(server.EMPTY_PAGE, params=params)
+    assert server_req.value.args["param1".encode()][0].decode() == "value1"
+    assert len(server_req.value.args["param1".encode()]) == 1
+    assert server_req.value.args["парам2".encode()][0].decode() == "знач2"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+def test_should_support_params_passed_as_strings(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    params = "?param1=value1&param1=value2&парам2=знач2"
+    with server.expect_request("/empty.html") as server_req:
+        getattr(context.request, method)(server.EMPTY_PAGE, params=params)
+    assert list(
+        map(lambda x: x.decode(), server_req.value.args["param1".encode()])
+    ) == ["value1", "value2"]
+    assert len(server_req.value.args["param1".encode()]) == 2
+    assert server_req.value.args["парам2".encode()][0].decode() == "знач2"
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+def test_should_support_fail_on_status_code(
+    context: BrowserContext, server: Server, method: str
+) -> None:
+    with pytest.raises(Error, match="404 Not Found"):
+        getattr(context.request, method)(
+            server.PREFIX + "/this-does-clearly-not-exist.html",
+            fail_on_status_code=True,
+        )
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+def test_should_support_ignore_https_errors_option(
+    context: BrowserContext, https_server: Server, method: str
+) -> None:
+    response = getattr(context.request, method)(
+        https_server.EMPTY_PAGE, ignore_https_errors=True
+    )
+    assert response.ok
+    assert response.status == 200
+
+
+def test_should_not_add_context_cookie_if_cookie_header_passed_as_parameter(
+    context: BrowserContext, server: Server
+) -> None:
+    context.add_cookies(
+        [
+            {
+                "name": "username",
+                "value": "John Doe",
+                "url": server.EMPTY_PAGE,
+                "expires": -1,
+                "httpOnly": False,
+                "secure": False,
+                "sameSite": "Lax",
+            }
+        ]
+    )
+    with server.expect_request("/empty.html") as server_req:
+        context.request.get(server.EMPTY_PAGE, headers={"Cookie": "foo=bar"})
+    assert server_req.value.getHeader("Cookie") == "foo=bar"
+
+
+@pytest.mark.parametrize("method", ["delete", "patch", "post", "put"])
+def test_should_support_post_data(
+    context: BrowserContext, method: str, server: Server
+) -> None:
+    def support_post_data(fetch_data: Any, request_post_data: Any) -> None:
+        with server.expect_request("/simple.json") as request:
+            response = getattr(context.request, method)(
+                server.PREFIX + "/simple.json", data=fetch_data
+            )
+        assert request.value.method.decode() == method.upper()
+        assert request.value.post_body == request_post_data
+        assert response.status == 200
+        assert response.url == server.PREFIX + "/simple.json"
+        assert request.value.getHeader("Content-Length") == str(
+            len(must(request.value.post_body))
+        )
+
+    support_post_data("My request", "My request".encode())
+    support_post_data(b"My request", "My request".encode())
+    support_post_data(["my", "request"], json.dumps(["my", "request"]).encode())
+    support_post_data({"my": "request"}, json.dumps({"my": "request"}).encode())
+    with pytest.raises(Error, match="Unsupported 'data' type: <class 'function'>"):
+        support_post_data(lambda: None, None)
+
+
+def test_should_support_application_x_www_form_urlencoded(
+    context: BrowserContext, server: Server
+) -> None:
+    with server.expect_request("/empty.html") as server_req:
+        context.request.post(
+            server.PREFIX + "/empty.html",
+            form={
+                "firstName": "John",
+                "lastName": "Doe",
+                "file": "f.js",
+            },
+        )
+    assert server_req.value.method == b"POST"
+    assert (
+        server_req.value.getHeader("Content-Type")
+        == "application/x-www-form-urlencoded"
+    )
+    body = must(server_req.value.post_body).decode()
+    assert server_req.value.getHeader("Content-Length") == str(len(body))
+    params: Dict[bytes, List[bytes]] = parse_qs(server_req.value.post_body)
+    assert params[b"firstName"] == [b"John"]
+    assert params[b"lastName"] == [b"Doe"]
+    assert params[b"file"] == [b"f.js"]
+
+
+def test_should_support_multipart_form_data(
+    context: BrowserContext, server: Server
+) -> None:
+    file: FilePayload = {
+        "name": "f.js",
+        "mimeType": "text/javascript",
+        "buffer": b"var x = 10;\r\n;console.log(x);",
+    }
+    with server.expect_request("/empty.html") as server_req:
+        context.request.post(
+            server.PREFIX + "/empty.html",
+            multipart={
+                "firstName": "John",
+                "lastName": "Doe",
+                "file": file,
+            },
+        )
+    assert server_req.value.method == b"POST"
+    content_type = server_req.value.getHeader("Content-Type")
+    assert content_type
+    assert content_type.startswith("multipart/form-data; ")
+    assert server_req.value.getHeader("Content-Length") == str(
+        len(must(server_req.value.post_body))
+    )
+    assert server_req.value.args[b"firstName"] == [b"John"]
+    assert server_req.value.args[b"lastName"] == [b"Doe"]
+    assert server_req.value.args[b"file"][0] == file["buffer"]
+
+
+def test_should_support_form_data_with_repeated_keys(
+    context: BrowserContext, server: Server
+) -> None:
+    form = FormData()
+    form.append("name", "John")
+    form.append("name", "Doe")
+    form.set("email", "john@example.com")
+    with server.expect_request("/empty.html") as server_req:
+        context.request.post(server.EMPTY_PAGE, form=form)
+    params = parse_qs(must(server_req.value.post_body))
+    assert params[b"name"] == [b"John", b"Doe"]
+    assert params[b"email"] == [b"john@example.com"]
+
+
+def test_should_reject_file_value_in_form(
+    context: BrowserContext, server: Server, tmp_path: Path
+) -> None:
+    file = tmp_path / "f.txt"
+    file.write_bytes(b"hello")
+    form = FormData()
+    form.set("attachment", file)
+    with pytest.raises(Error, match="Use 'multipart' for file uploads"):
+        context.request.post(server.EMPTY_PAGE, form=form)
+
+
+def test_should_support_multipart_form_data_with_multiple_files_in_one_field(
+    context: BrowserContext, server: Server
+) -> None:
+    file1: FilePayload = {
+        "name": "f1.txt",
+        "mimeType": "text/plain",
+        "buffer": b"file 1 content",
+    }
+    file2: FilePayload = {
+        "name": "f2.txt",
+        "mimeType": "text/plain",
+        "buffer": b"file 2 content",
+    }
+    form = FormData()
+    form.append("files", file1)
+    form.append("files", file2)
+    form.set("user", "alice")
+    with server.expect_request("/empty.html") as server_req:
+        context.request.post(server.EMPTY_PAGE, multipart=form)
+    assert cast(str, server_req.value.getHeader("Content-Type")).startswith(
+        "multipart/form-data; "
+    )
+    assert server_req.value.args[b"user"] == [b"alice"]
+    assert server_req.value.args[b"files"] == [file1["buffer"], file2["buffer"]]
+
+
+def test_should_support_multipart_form_data_with_path_value(
+    context: BrowserContext, server: Server, tmp_path: Path
+) -> None:
+    file = tmp_path / "data.csv"
+    file.write_bytes(b"a,b,c\n1,2,3\n")
+    form = FormData()
+    form.set("attachment", file)
+    with server.expect_request("/empty.html") as server_req:
+        context.request.post(server.EMPTY_PAGE, multipart=form)
+    assert cast(str, server_req.value.getHeader("Content-Type")).startswith(
+        "multipart/form-data; "
+    )
+    assert server_req.value.args[b"attachment"] == [b"a,b,c\n1,2,3\n"]
+
+
+def test_should_add_default_headers(
+    context: BrowserContext, page: Page, server: Server
+) -> None:
+    with server.expect_request("/empty.html") as server_req:
+        context.request.get(server.EMPTY_PAGE)
+    assert server_req.value.getHeader("Accept") == "*/*"
+    assert server_req.value.getHeader("Accept-Encoding") == "gzip,deflate,br"
+    assert server_req.value.getHeader("User-Agent") == page.evaluate(
+        "() => navigator.userAgent"
+    )
diff --git a/tests/sync/test_fetch_global.py b/tests/sync/test_fetch_global.py
new file mode 100644
index 000000000..5cb3abc5b
--- /dev/null
+++ b/tests/sync/test_fetch_global.py
@@ -0,0 +1,390 @@
+# 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 json
+from pathlib import Path
+from urllib.parse import urlparse
+
+import pytest
+
+from playwright.sync_api import APIResponse, Error, Playwright, StorageState
+from tests.server import Server, TestServerRequest
+
+
+@pytest.mark.parametrize(
+    "method", ["fetch", "delete", "get", "head", "patch", "post", "put"]
+)
+def test_should_work(playwright: Playwright, method: str, server: Server) -> None:
+    request = playwright.request.new_context()
+    response: APIResponse = getattr(request, method)(server.PREFIX + "/simple.json")
+    assert response.status == 200
+    assert response.status_text == "OK"
+    assert response.ok is True
+    assert response.url == server.PREFIX + "/simple.json"
+    assert response.headers["content-type"] == "application/json"
+    assert {
+        "name": "Content-Type",
+        "value": "application/json",
+    } in response.headers_array
+    assert response.text() == ("" if method == "head" else '{"foo": "bar"}\n')
+
+
+def test_should_dispose_global_request(playwright: Playwright, server: Server) -> None:
+    request = playwright.request.new_context()
+    response = request.get(server.PREFIX + "/simple.json")
+    assert response.json() == {"foo": "bar"}
+    response.dispose()
+    with pytest.raises(Error, match="Response has been disposed"):
+        response.body()
+
+
+def test_should_support_global_user_agent_option(
+    playwright: Playwright, server: Server
+) -> None:
+    request = playwright.request.new_context(user_agent="My Agent")
+    response = request.get(server.PREFIX + "/empty.html")
+    with server.expect_request("/empty.html") as server_req:
+        request.get(server.EMPTY_PAGE)
+    assert response.ok is True
+    assert response.url == server.EMPTY_PAGE
+
+    assert server_req.value.getHeader("user-agent") == "My Agent"
+
+
+def test_should_support_global_timeout_option(
+    playwright: Playwright, server: Server
+) -> None:
+    request = playwright.request.new_context(timeout=100)
+    server.set_route("/empty.html", lambda req: None)
+    with pytest.raises(Error, match="Timeout 100ms exceeded"):
+        request.get(server.EMPTY_PAGE)
+
+
+def test_should_support_timeout_option_in_get_method(
+    playwright: Playwright, server: Server
+) -> None:
+    request = playwright.request.new_context()
+    server.set_route("/empty.html", lambda req: None)
+    with pytest.raises(Error, match="APIRequestContext.get: Timeout 123ms exceeded."):
+        request.get(server.EMPTY_PAGE, timeout=123)
+
+
+def test_should_propagate_extra_http_headers_with_redirects(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_redirect("/a/redirect1", "/b/c/redirect2")
+    server.set_redirect("/b/c/redirect2", "/simple.json")
+    request = playwright.request.new_context(extra_http_headers={"My-Secret": "Value"})
+    with server.expect_request("/a/redirect1") as server_req1:
+        with server.expect_request("/b/c/redirect2") as server_req2:
+            with server.expect_request("/simple.json") as server_req3:
+                request.get(f"{server.PREFIX}/a/redirect1")
+    assert server_req1.value.getHeader("my-secret") == "Value"
+    assert server_req2.value.getHeader("my-secret") == "Value"
+    assert server_req3.value.getHeader("my-secret") == "Value"
+
+
+def test_should_support_global_http_credentials_option(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    request1 = playwright.request.new_context()
+    response1 = request1.get(server.EMPTY_PAGE)
+    assert response1.status == 401
+    response1.dispose()
+
+    request2 = playwright.request.new_context(
+        http_credentials={"username": "user", "password": "pass"}
+    )
+    response2 = request2.get(server.EMPTY_PAGE)
+    assert response2.status == 200
+    assert response2.ok is True
+    response2.dispose()
+
+
+def test_should_return_error_with_wrong_credentials(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    request = playwright.request.new_context(
+        http_credentials={"username": "user", "password": "wrong"}
+    )
+    response = request.get(server.EMPTY_PAGE)
+    assert response.status == 401
+    assert response.ok is False
+
+
+def test_should_work_with_correct_credentials_and_matching_origin(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    request = playwright.request.new_context(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX,
+        }
+    )
+    response = request.get(server.EMPTY_PAGE)
+    assert response.status == 200
+    response.dispose()
+
+
+def test_should_work_with_correct_credentials_and_matching_origin_case_insensitive(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    request = playwright.request.new_context(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.upper(),
+        }
+    )
+    response = request.get(server.EMPTY_PAGE)
+    assert response.status == 200
+    response.dispose()
+
+
+def test_should_return_error_with_correct_credentials_and_mismatching_scheme(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    request = playwright.request.new_context(
+        http_credentials={
+            "username": "user",
+            "password": "pass",
+            "origin": server.PREFIX.replace("http://", "https://"),
+        }
+    )
+    response = request.get(server.EMPTY_PAGE)
+    assert response.status == 401
+    response.dispose()
+
+
+def test_should_return_error_with_correct_credentials_and_mismatching_hostname(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    hostname = urlparse(server.PREFIX).hostname
+    assert hostname
+    origin = server.PREFIX.replace(hostname, "mismatching-hostname")
+    request = playwright.request.new_context(
+        http_credentials={"username": "user", "password": "pass", "origin": origin}
+    )
+    response = request.get(server.EMPTY_PAGE)
+    assert response.status == 401
+    response.dispose()
+
+
+def test_should_return_error_with_correct_credentials_and_mismatching_port(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_auth("/empty.html", "user", "pass")
+    origin = server.PREFIX.replace(str(server.PORT), str(server.PORT + 1))
+    request = playwright.request.new_context(
+        http_credentials={"username": "user", "password": "pass", "origin": origin}
+    )
+    response = request.get(server.EMPTY_PAGE)
+    assert response.status == 401
+    response.dispose()
+
+
+def test_should_support_global_ignore_https_errors_option(
+    playwright: Playwright, https_server: Server
+) -> None:
+    request = playwright.request.new_context(ignore_https_errors=True)
+    response = request.get(https_server.EMPTY_PAGE)
+    assert response.status == 200
+    assert response.ok is True
+    assert response.url == https_server.EMPTY_PAGE
+    response.dispose()
+
+
+def test_should_resolve_url_relative_to_global_base_url_option(
+    playwright: Playwright, server: Server
+) -> None:
+    request = playwright.request.new_context(base_url=server.PREFIX)
+    response = request.get("/empty.html")
+    assert response.status == 200
+    assert response.ok is True
+    assert response.url == server.EMPTY_PAGE
+    response.dispose()
+
+
+def test_should_use_playwright_as_a_user_agent(
+    playwright: Playwright, server: Server
+) -> None:
+    request = playwright.request.new_context()
+    with server.expect_request("/empty.html") as server_req:
+        request.get(server.EMPTY_PAGE)
+    assert str(server_req.value.getHeader("User-Agent")).startswith("Playwright/")
+    request.dispose()
+
+
+def test_should_return_empty_body(playwright: Playwright, server: Server) -> None:
+    request = playwright.request.new_context()
+    response = request.get(server.EMPTY_PAGE)
+    body = response.body()
+    assert len(body) == 0
+    assert response.text() == ""
+    request.dispose()
+    with pytest.raises(Error, match="Response has been disposed"):
+        response.body()
+
+
+def test_storage_state_should_round_trip_through_file(
+    playwright: Playwright, tmp_path: Path
+) -> None:
+    expected: StorageState = {
+        "cookies": [
+            {
+                "name": "a",
+                "value": "b",
+                "domain": "a.b.one.com",
+                "path": "/",
+                "expires": -1,
+                "httpOnly": False,
+                "secure": False,
+                "sameSite": "Lax",
+            }
+        ],
+        "origins": [],
+    }
+    request = playwright.request.new_context(storage_state=expected)
+    path = tmp_path / "storage-state.json"
+    actual = request.storage_state(path=path)
+    assert actual == expected
+
+    written = path.read_text("utf8")
+    assert json.loads(written) == expected
+
+    request2 = playwright.request.new_context(storage_state=path)
+    state2 = request2.storage_state()
+    assert state2 == expected
+
+
+def test_should_throw_an_error_when_max_redirects_is_exceeded(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_redirect("/a/redirect1", "/b/c/redirect2")
+    server.set_redirect("/b/c/redirect2", "/b/c/redirect3")
+    server.set_redirect("/b/c/redirect3", "/b/c/redirect4")
+    server.set_redirect("/b/c/redirect4", "/simple.json")
+
+    request = playwright.request.new_context()
+    for method in ["GET", "PUT", "POST", "OPTIONS", "HEAD", "PATCH"]:
+        for max_redirects in [1, 2, 3]:
+            with pytest.raises(Error) as exc_info:
+                request.fetch(
+                    server.PREFIX + "/a/redirect1",
+                    method=method,
+                    max_redirects=max_redirects,
+                )
+            assert "Max redirect count exceeded" in str(exc_info)
+
+
+def test_should_not_follow_redirects_when_max_redirects_is_set_to_0(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_redirect("/a/redirect1", "/b/c/redirect2")
+    server.set_redirect("/b/c/redirect2", "/simple.json")
+
+    request = playwright.request.new_context()
+    for method in ["GET", "PUT", "POST", "OPTIONS", "HEAD", "PATCH"]:
+        response = request.fetch(
+            server.PREFIX + "/a/redirect1", method=method, max_redirects=0
+        )
+        assert response.headers["location"] == "/b/c/redirect2"
+        assert response.status == 302
+
+
+def test_should_throw_an_error_when_max_redirects_is_less_than_0(
+    playwright: Playwright,
+    server: Server,
+) -> None:
+    request = playwright.request.new_context()
+    for method in ["GET", "PUT", "POST", "OPTIONS", "HEAD", "PATCH"]:
+        with pytest.raises(AssertionError) as exc_info:
+            request.fetch(
+                server.PREFIX + "/a/redirect1", method=method, max_redirects=-1
+            )
+        assert "'max_redirects' must be greater than or equal to '0'" in str(exc_info)
+
+
+def test_should_serialize_null_values_in_json(
+    playwright: Playwright, server: Server
+) -> None:
+    request = playwright.request.new_context()
+    server.set_route("/echo", lambda req: (req.write(req.post_body), req.finish()))
+    response = request.post(server.PREFIX + "/echo", data={"foo": None})
+    assert response.status == 200
+    assert response.text() == '{"foo": null}'
+    request.dispose()
+
+
+def test_should_throw_when_fail_on_status_code_is_true(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_route(
+        "/empty.html",
+        lambda req: (
+            req.setResponseCode(404),
+            req.setHeader("Content-Length", "10"),
+            req.setHeader("Content-Type", "text/plain"),
+            req.write(b"Not found."),
+            req.finish(),
+        ),
+    )
+    request = playwright.request.new_context(fail_on_status_code=True)
+    with pytest.raises(Error, match="404 Not Found"):
+        request.fetch(server.EMPTY_PAGE)
+    request.dispose()
+
+
+def test_should_not_throw_when_fail_on_status_code_is_false(
+    playwright: Playwright, server: Server
+) -> None:
+    server.set_route(
+        "/empty.html",
+        lambda req: (
+            req.setResponseCode(404),
+            req.setHeader("Content-Length", "10"),
+            req.setHeader("Content-Type", "text/plain"),
+            req.write(b"Not found."),
+            req.finish(),
+        ),
+    )
+    request = playwright.request.new_context(fail_on_status_code=False)
+    response = request.fetch(server.EMPTY_PAGE)
+    assert response.status == 404
+    request.dispose()
+
+
+def test_should_follow_max_redirects(playwright: Playwright, server: Server) -> None:
+    redirect_count = 0
+
+    def _handle_request(req: TestServerRequest) -> None:
+        nonlocal redirect_count
+        redirect_count += 1
+        req.setResponseCode(301)
+        req.setHeader("Location", server.EMPTY_PAGE)
+        req.finish()
+
+    server.set_route("/empty.html", _handle_request)
+    request = playwright.request.new_context(max_redirects=1)
+    with pytest.raises(Error, match="Max redirect count exceeded"):
+        request.fetch(server.EMPTY_PAGE)
+    assert redirect_count == 2
+    request.dispose()
diff --git a/tests/sync/test_fill.py b/tests/sync/test_fill.py
new file mode 100644
index 000000000..e43b9a868
--- /dev/null
+++ b/tests/sync/test_fill.py
@@ -0,0 +1,28 @@
+# 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.
+
+from playwright.sync_api import Page
+from tests.server import Server
+
+
+def test_fill_textarea(page: Page, server: Server) -> None:
+    page.goto(f"{server.PREFIX}/input/textarea.html")
+    page.fill("textarea", "some value")
+    assert page.evaluate("result") == "some value"
+
+
+def test_fill_input(page: Page, server: Server) -> None:
+    page.goto(f"{server.PREFIX}/input/textarea.html")
+    page.fill("input", "some value")
+    assert page.evaluate("result") == "some value"
diff --git a/tests/sync/test_har.py b/tests/sync/test_har.py
index efa582d38..6ac848b8a 100644
--- a/tests/sync/test_har.py
+++ b/tests/sync/test_har.py
@@ -12,13 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import base64
 import json
 import os
+import re
+import zipfile
+from pathlib import Path
+from typing import Any, cast
 
+import pytest
 
-def test_should_work(browser, server, tmpdir):
-    path = os.path.join(tmpdir, "log.har")
+from playwright.sync_api import Browser, BrowserContext, Error, Page, Route, expect
+from tests.server import Server
+
+
+def test_should_work(browser: Browser, server: Server, tmp_path: Path) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = browser.new_context(record_har_path=path)
     page = context.new_page()
     page.goto(server.EMPTY_PAGE)
@@ -28,8 +36,26 @@ def test_should_work(browser, server, tmpdir):
         assert "log" in data
 
 
-def test_should_omit_content(browser, server, tmpdir):
-    path = os.path.join(tmpdir, "log.har")
+def test_should_omit_content(browser: Browser, server: Server, tmp_path: Path) -> None:
+    path = os.path.join(tmp_path, "log.har")
+    context = browser.new_context(record_har_path=path, record_har_content="omit")
+    page = context.new_page()
+    page.goto(server.PREFIX + "/har.html")
+    context.close()
+    with open(path) as f:
+        data = json.load(f)
+        assert "log" in data
+        log = data["log"]
+
+        content1 = log["entries"][0]["response"]["content"]
+        assert "text" not in content1
+        assert "encoding" not in content1
+
+
+def test_should_omit_content_legacy(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = browser.new_context(record_har_path=path, record_har_omit_content=True)
     page = context.new_page()
     page.goto(server.PREFIX + "/har.html")
@@ -41,10 +67,72 @@ def test_should_omit_content(browser, server, tmpdir):
 
         content1 = log["entries"][0]["response"]["content"]
         assert "text" not in content1
+        assert "encoding" not in content1
+
+
+def test_should_attach_content(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har.zip")
+    context = browser.new_context(
+        record_har_path=path,
+        record_har_content="attach",
+    )
+    page = context.new_page()
+    page.goto(server.PREFIX + "/har.html")
+    page.evaluate("() => fetch('/pptr.png').then(r => r.arrayBuffer())")
+    context.close()
+    with zipfile.ZipFile(path) as z:
+        with z.open("har.har") as har:
+            entries = json.load(har)["log"]["entries"]
+
+            assert "encoding" not in entries[0]["response"]["content"]
+            assert (
+                entries[0]["response"]["content"]["mimeType"]
+                == "text/html; charset=utf-8"
+            )
+            assert (
+                "75841480e2606c03389077304342fac2c58ccb1b"
+                in entries[0]["response"]["content"]["_file"]
+            )
+            assert entries[0]["response"]["content"]["size"] >= 96
+            assert entries[0]["response"]["content"]["compression"] == 0
+
+            assert "encoding" not in entries[1]["response"]["content"]
+            assert (
+                entries[1]["response"]["content"]["mimeType"]
+                == "text/css; charset=utf-8"
+            )
+            assert (
+                "79f739d7bc88e80f55b9891a22bf13a2b4e18adb"
+                in entries[1]["response"]["content"]["_file"]
+            )
+            assert entries[1]["response"]["content"]["size"] >= 37
+            assert entries[1]["response"]["content"]["compression"] == 0
+
+            assert "encoding" not in entries[2]["response"]["content"]
+            assert entries[2]["response"]["content"]["mimeType"] == "image/png"
+            assert (
+                "a4c3a18f0bb83f5d9fe7ce561e065c36205762fa"
+                in entries[2]["response"]["content"]["_file"]
+            )
+            assert entries[2]["response"]["content"]["size"] >= 6000
+            assert entries[2]["response"]["content"]["compression"] == 0
+
+            with z.open("75841480e2606c03389077304342fac2c58ccb1b.html") as f:
+                assert b"HAR Page" in f.read()
 
+            with z.open("79f739d7bc88e80f55b9891a22bf13a2b4e18adb.css") as f:
+                assert b"pink" in f.read()
 
-def test_should_include_content(browser, server, tmpdir):
-    path = os.path.join(tmpdir, "log.har")
+            with z.open("a4c3a18f0bb83f5d9fe7ce561e065c36205762fa.png") as f:
+                assert len(f.read()) == entries[2]["response"]["content"]["size"]
+
+
+def test_should_include_content(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
     context = browser.new_context(record_har_path=path)
     page = context.new_page()
     page.goto(server.PREFIX + "/har.html")
@@ -55,8 +143,494 @@ def test_should_include_content(browser, server, tmpdir):
         log = data["log"]
 
         content1 = log["entries"][0]["response"]["content"]
-        print(content1)
-        assert content1["encoding"] == "base64"
-        assert content1["mimeType"] == "text/html"
-        s = base64.b64decode(content1["text"]).decode()
-        assert "HAR Page" in s
+        assert content1["mimeType"] == "text/html; charset=utf-8"
+        assert "HAR Page" in content1["text"]
+
+
+def test_should_default_to_full_mode(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
+    context = browser.new_context(
+        record_har_path=path,
+    )
+    page = context.new_page()
+    page.goto(server.PREFIX + "/har.html")
+    context.close()
+    with open(path) as f:
+        data = json.load(f)
+        assert "log" in data
+        log = data["log"]
+        assert log["entries"][0]["request"]["bodySize"] >= 0
+
+
+def test_should_support_minimal_mode(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
+    context = browser.new_context(
+        record_har_path=path,
+        record_har_mode="minimal",
+    )
+    page = context.new_page()
+    page.goto(server.PREFIX + "/har.html")
+    context.close()
+    with open(path) as f:
+        data = json.load(f)
+        assert "log" in data
+        log = data["log"]
+        assert log["entries"][0]["request"]["bodySize"] == -1
+
+
+def test_should_filter_by_glob(browser: Browser, server: Server, tmp_path: str) -> None:
+    path = os.path.join(tmp_path, "log.har")
+    context = browser.new_context(
+        base_url=server.PREFIX,
+        record_har_path=path,
+        record_har_url_filter="/*.css",
+        ignore_https_errors=True,
+    )
+    page = context.new_page()
+    page.goto(server.PREFIX + "/har.html")
+    context.close()
+    with open(path) as f:
+        data = json.load(f)
+        assert "log" in data
+        log = data["log"]
+        assert len(log["entries"]) == 1
+        assert log["entries"][0]["request"]["url"].endswith("one-style.css")
+
+
+def test_should_filter_by_regexp(
+    browser: Browser, server: Server, tmp_path: str
+) -> None:
+    path = os.path.join(tmp_path, "log.har")
+    context = browser.new_context(
+        base_url=server.PREFIX,
+        record_har_path=path,
+        record_har_url_filter=re.compile("HAR.X?HTML", re.I),
+        ignore_https_errors=True,
+    )
+    page = context.new_page()
+    page.goto(server.PREFIX + "/har.html")
+    context.close()
+    with open(path) as f:
+        data = json.load(f)
+        assert "log" in data
+        log = data["log"]
+        assert len(log["entries"]) == 1
+        assert log["entries"][0]["request"]["url"].endswith("har.html")
+
+
+def test_should_context_route_from_har_matching_the_method_and_following_redirects(
+    context: BrowserContext, assetdir: Path
+) -> None:
+    context.route_from_har(har=assetdir / "har-fulfill.har")
+    page = context.new_page()
+    page.goto("http://no.playwright/")
+    # HAR contains a redirect for the script that should be followed automatically.
+    assert page.evaluate("window.value") == "foo"
+    # HAR contains a POST for the css file that should not be used.
+    expect(page.locator("body")).to_have_css("background-color", "rgb(255, 0, 0)")
+
+
+def test_should_page_route_from_har_matching_the_method_and_following_redirects(
+    page: Page, assetdir: Path
+) -> None:
+    page.route_from_har(har=assetdir / "har-fulfill.har")
+    page.goto("http://no.playwright/")
+    # HAR contains a redirect for the script that should be followed automatically.
+    assert page.evaluate("window.value") == "foo"
+    # HAR contains a POST for the css file that should not be used.
+    expect(page.locator("body")).to_have_css("background-color", "rgb(255, 0, 0)")
+
+
+def test_fallback_continue_should_continue_when_not_found_in_har(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    context.route_from_har(har=assetdir / "har-fulfill.har", not_found="fallback")
+    page = context.new_page()
+    page.goto(server.PREFIX + "/one-style.html")
+    expect(page.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+
+
+def test_by_default_should_abort_requests_not_found_in_har(
+    context: BrowserContext,
+    server: Server,
+    assetdir: Path,
+    is_chromium: bool,
+    is_webkit: bool,
+) -> None:
+    context.route_from_har(har=assetdir / "har-fulfill.har")
+    page = context.new_page()
+
+    with pytest.raises(Error) as exc_info:
+        page.goto(server.EMPTY_PAGE)
+    assert exc_info.value
+    if is_chromium:
+        assert "net::ERR_FAILED" in exc_info.value.message
+    elif is_webkit:
+        assert "Blocked by Web Inspector" in exc_info.value.message
+    else:
+        assert "NS_ERROR_FAILURE" in exc_info.value.message
+
+
+def test_fallback_continue_should_continue_requests_on_bad_har(
+    context: BrowserContext, server: Server, tmp_path: Path
+) -> None:
+    path_to_invalid_har = tmp_path / "invalid.har"
+    with path_to_invalid_har.open("w") as f:
+        json.dump({"log": {}}, f)
+    context.route_from_har(har=path_to_invalid_har, not_found="fallback")
+    page = context.new_page()
+    page.goto(server.PREFIX + "/one-style.html")
+    expect(page.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+
+
+def test_should_only_handle_requests_matching_url_filter(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    context.route_from_har(
+        har=assetdir / "har-fulfill.har", not_found="fallback", url="**/*.js"
+    )
+    page = context.new_page()
+
+    def handler(route: Route) -> None:
+        assert route.request.url == "http://no.playwright/"
+        route.fulfill(
+            status=200,
+            content_type="text/html",
+            body='<script src="./script.js"></script><div>hello</div>',
+        )
+
+    context.route("http://no.playwright/", handler)
+    page.goto("http://no.playwright/")
+    assert page.evaluate("window.value") == "foo"
+    expect(page.locator("body")).to_have_css("background-color", "rgba(0, 0, 0, 0)")
+
+
+def test_should_only_handle_requests_matching_url_filter_no_fallback(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    context.route_from_har(har=assetdir / "har-fulfill.har", url="**/*.js")
+    page = context.new_page()
+
+    def handler(route: Route) -> None:
+        assert route.request.url == "http://no.playwright/"
+        route.fulfill(
+            status=200,
+            content_type="text/html",
+            body='<script src="./script.js"></script><div>hello</div>',
+        )
+
+    context.route("http://no.playwright/", handler)
+    page.goto("http://no.playwright/")
+    assert page.evaluate("window.value") == "foo"
+    expect(page.locator("body")).to_have_css("background-color", "rgba(0, 0, 0, 0)")
+
+
+def test_should_only_handle_requests_matching_url_filter_no_fallback_page(
+    page: Page, server: Server, assetdir: Path
+) -> None:
+    page.route_from_har(har=assetdir / "har-fulfill.har", url="**/*.js")
+
+    def handler(route: Route) -> None:
+        assert route.request.url == "http://no.playwright/"
+        route.fulfill(
+            status=200,
+            content_type="text/html",
+            body='<script src="./script.js"></script><div>hello</div>',
+        )
+
+    page.route("http://no.playwright/", handler)
+    page.goto("http://no.playwright/")
+    assert page.evaluate("window.value") == "foo"
+    expect(page.locator("body")).to_have_css("background-color", "rgba(0, 0, 0, 0)")
+
+
+def test_should_support_regex_filter(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    context.route_from_har(
+        har=assetdir / "har-fulfill.har",
+        url=re.compile(r".*(\.js|.*\.css|no.playwright\/)"),
+    )
+    page = context.new_page()
+    page.goto("http://no.playwright/")
+    assert page.evaluate("window.value") == "foo"
+    expect(page.locator("body")).to_have_css("background-color", "rgb(255, 0, 0)")
+
+
+def test_should_go_back_to_redirected_navigation(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    context.route_from_har(
+        har=assetdir / "har-redirect.har", url=re.compile(r"/.*theverge.*/")
+    )
+    page = context.new_page()
+    page.goto("https://theverge.com/")
+    page.goto(server.EMPTY_PAGE)
+    expect(page).to_have_url(server.EMPTY_PAGE)
+
+    response = page.go_back()
+    assert response
+    expect(page).to_have_url("https://www.theverge.com/")
+    assert response.request.url == "https://www.theverge.com/"
+    assert page.evaluate("window.location.href") == "https://www.theverge.com/"
+
+
+@pytest.mark.skip_browser(
+    "firefox"
+)  # skipped upstream (https://github.com/microsoft/playwright/blob/6a8d835145e2f4002ee00b67a80a1f70af956703/tests/library/browsercontext-har.spec.ts#L214)
+def test_should_go_forward_to_redirected_navigation(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    context.route_from_har(
+        har=assetdir / "har-redirect.har", url=re.compile(r"/.*theverge.*/")
+    )
+    page = context.new_page()
+    page.goto("https://theverge.com/")
+    page.goto(server.EMPTY_PAGE)
+    expect(page).to_have_url(server.EMPTY_PAGE)
+    page.goto("https://theverge.com/")
+    expect(page).to_have_url("https://www.theverge.com/")
+    page.go_back()
+    expect(page).to_have_url(server.EMPTY_PAGE)
+    response = page.go_forward()
+    assert response
+    expect(page).to_have_url("https://www.theverge.com/")
+    assert response.request.url == "https://www.theverge.com/"
+    assert page.evaluate("window.location.href") == "https://www.theverge.com/"
+
+
+def test_should_reload_redirected_navigation(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    context.route_from_har(
+        har=assetdir / "har-redirect.har", url=re.compile(r"/.*theverge.*/")
+    )
+    page = context.new_page()
+    page.goto("https://theverge.com/")
+    expect(page).to_have_url("https://www.theverge.com/")
+    response = page.reload()
+    assert response
+    expect(page).to_have_url("https://www.theverge.com/")
+    assert response.request.url == "https://www.theverge.com/"
+    assert page.evaluate("window.location.href") == "https://www.theverge.com/"
+
+
+def test_should_fulfill_from_har_with_content_in_a_file(
+    context: BrowserContext, server: Server, assetdir: Path
+) -> None:
+    context.route_from_har(har=assetdir / "har-sha1.har")
+    page = context.new_page()
+    page.goto("http://no.playwright/")
+    assert page.content() == "<html><head></head><body>Hello, world</body></html>"
+
+
+def test_should_round_trip_har_zip(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.zip"
+    context_1 = browser.new_context(record_har_mode="minimal", record_har_path=har_path)
+    page_1 = context_1.new_page()
+    page_1.goto(server.PREFIX + "/one-style.html")
+    context_1.close()
+
+    context_2 = browser.new_context()
+    context_2.route_from_har(har=har_path, not_found="abort")
+    page_2 = context_2.new_page()
+    page_2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in page_2.content()
+    expect(page_2.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+    context_2.close()
+
+
+def test_should_round_trip_har_with_post_data(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    server.set_route(
+        "/echo", lambda req: (req.write(cast(Any, req).post_body), req.finish())
+    )
+    fetch_function = """
+        async (body) => {
+            const response = await fetch('/echo', { method: 'POST', body });
+            return response.text();
+        };
+    """
+    har_path = tmp_path / "har.zip"
+    context_1 = browser.new_context(record_har_mode="minimal", record_har_path=har_path)
+    page_1 = context_1.new_page()
+    page_1.goto(server.EMPTY_PAGE)
+
+    assert page_1.evaluate(fetch_function, "1") == "1"
+    assert page_1.evaluate(fetch_function, "2") == "2"
+    assert page_1.evaluate(fetch_function, "3") == "3"
+    context_1.close()
+
+    context_2 = browser.new_context()
+    context_2.route_from_har(har=har_path, not_found="abort")
+    page_2 = context_2.new_page()
+    page_2.goto(server.EMPTY_PAGE)
+    assert page_2.evaluate(fetch_function, "1") == "1"
+    assert page_2.evaluate(fetch_function, "2") == "2"
+    assert page_2.evaluate(fetch_function, "3") == "3"
+    with pytest.raises(Exception):
+        page_2.evaluate(fetch_function, "4")
+    context_2.close()
+
+
+def test_should_disambiguate_by_header(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    server.set_route(
+        "/echo",
+        lambda req: (req.write(cast(str, req.getHeader("baz")).encode()), req.finish()),
+    )
+    fetch_function = """
+        async (bazValue) => {
+            const response = await fetch('/echo', {
+            method: 'POST',
+            body: '',
+            headers: {
+                foo: 'foo-value',
+                bar: 'bar-value',
+                baz: bazValue,
+            }
+            });
+            return response.text();
+        };
+    """
+    har_path = tmp_path / "har.zip"
+    context_1 = browser.new_context(record_har_mode="minimal", record_har_path=har_path)
+    page_1 = context_1.new_page()
+    page_1.goto(server.EMPTY_PAGE)
+
+    assert page_1.evaluate(fetch_function, "baz1") == "baz1"
+    assert page_1.evaluate(fetch_function, "baz2") == "baz2"
+    assert page_1.evaluate(fetch_function, "baz3") == "baz3"
+    context_1.close()
+
+    context_2 = browser.new_context()
+    context_2.route_from_har(har=har_path)
+    page_2 = context_2.new_page()
+    page_2.goto(server.EMPTY_PAGE)
+    assert page_2.evaluate(fetch_function, "baz1") == "baz1"
+    assert page_2.evaluate(fetch_function, "baz2") == "baz2"
+    assert page_2.evaluate(fetch_function, "baz3") == "baz3"
+    assert page_2.evaluate(fetch_function, "baz4") == "baz1"
+    context_2.close()
+
+
+def test_should_produce_extracted_zip(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.har"
+    context = browser.new_context(
+        record_har_mode="minimal", record_har_path=har_path, record_har_content="attach"
+    )
+    page_1 = context.new_page()
+    page_1.goto(server.PREFIX + "/one-style.html")
+    context.close()
+
+    assert har_path.exists()
+    with har_path.open() as r:
+        content = r.read()
+        assert "log" in content
+        assert "background-color" not in r.read()
+
+    context_2 = browser.new_context()
+    context_2.route_from_har(har_path, not_found="abort")
+    page_2 = context_2.new_page()
+    page_2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in page_2.content()
+    expect(page_2.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+    context_2.close()
+
+
+def test_should_update_har_zip_for_context(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.zip"
+    context = browser.new_context()
+    context.route_from_har(har_path, update=True)
+    page_1 = context.new_page()
+    page_1.goto(server.PREFIX + "/one-style.html")
+    context.close()
+
+    assert har_path.exists()
+
+    context_2 = browser.new_context()
+    context_2.route_from_har(har_path, not_found="abort")
+    page_2 = context_2.new_page()
+    page_2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in page_2.content()
+    expect(page_2.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+    context_2.close()
+
+
+def test_should_update_har_zip_for_page(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.zip"
+    context = browser.new_context()
+    page_1 = context.new_page()
+    page_1.route_from_har(har_path, update=True)
+    page_1.goto(server.PREFIX + "/one-style.html")
+    context.close()
+
+    assert har_path.exists()
+
+    context_2 = browser.new_context()
+    page_2 = context_2.new_page()
+    page_2.route_from_har(har_path, not_found="abort")
+    page_2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in page_2.content()
+    expect(page_2.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+    context_2.close()
+
+
+def test_should_update_har_zip_for_page_with_different_options(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.zip"
+    context1 = browser.new_context()
+    page1 = context1.new_page()
+    page1.route_from_har(
+        har_path, update=True, update_content="embed", update_mode="full"
+    )
+    page1.goto(server.PREFIX + "/one-style.html")
+    context1.close()
+
+    context2 = browser.new_context()
+    page2 = context2.new_page()
+    page2.route_from_har(har_path, not_found="abort")
+    page2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in page2.content()
+    expect(page2.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+    context2.close()
+
+
+def test_should_update_extracted_har_zip_for_page(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    har_path = tmp_path / "har.har"
+    context = browser.new_context()
+    page_1 = context.new_page()
+    page_1.route_from_har(har_path, update=True)
+    page_1.goto(server.PREFIX + "/one-style.html")
+    context.close()
+
+    assert har_path.exists()
+    with har_path.open() as r:
+        content = r.read()
+        assert "log" in content
+        assert "background-color" not in r.read()
+
+    context_2 = browser.new_context()
+    page_2 = context_2.new_page()
+    page_2.route_from_har(har_path, not_found="abort")
+    page_2.goto(server.PREFIX + "/one-style.html")
+    assert "hello, world!" in page_2.content()
+    expect(page_2.locator("body")).to_have_css("background-color", "rgb(255, 192, 203)")
+    context_2.close()
diff --git a/tests/sync/test_input.py b/tests/sync/test_input.py
index 86a64d106..98b4fda55 100644
--- a/tests/sync/test_input.py
+++ b/tests/sync/test_input.py
@@ -12,8 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
+from pathlib import Path
+from typing import Any
 
-def test_expect_file_chooser(page, server):
+from playwright.sync_api import Page
+
+
+def test_expect_file_chooser(page: Page) -> None:
     page.set_content("<input type=file></input>")
     with page.expect_file_chooser() as fc_info:
         page.click('input[type="file"]')
@@ -21,3 +27,21 @@ def test_expect_file_chooser(page, server):
     fc.set_files(
         {"name": "test.txt", "mimeType": "text/plain", "buffer": b"Hello World"}
     )
+
+
+def test_set_input_files_should_preserve_last_modified_timestamp(
+    page: Page,
+    assetdir: Path,
+) -> None:
+    page.set_content("<input type=file multiple=true/>")
+    input = page.locator("input")
+    files: Any = ["file-to-upload.txt", "file-to-upload-2.txt"]
+    input.set_input_files([assetdir / file for file in files])
+    assert input.evaluate("input => [...input.files].map(f => f.name)") == files
+    timestamps = input.evaluate("input => [...input.files].map(f => f.lastModified)")
+    expected_timestamps = [os.path.getmtime(assetdir / file) * 1000 for file in files]
+
+    # On Linux browser sometimes reduces the timestamp by 1ms: 1696272058110.0715  -> 1696272058109 or even
+    # rounds it to seconds in WebKit: 1696272058110 -> 1696272058000.
+    for i in range(len(timestamps)):
+        assert abs(timestamps[i] - expected_timestamps[i]) < 1000
diff --git a/tests/sync/test_launcher.py b/tests/sync/test_launcher.py
new file mode 100644
index 000000000..6b89b79a8
--- /dev/null
+++ b/tests/sync/test_launcher.py
@@ -0,0 +1,97 @@
+# 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 os
+from pathlib import Path
+from typing import Dict
+
+import pytest
+
+from playwright.sync_api import BrowserType, Error
+
+
+@pytest.mark.skip_browser("firefox")
+def test_browser_type_launch_should_throw_if_page_argument_is_passed(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
+    with pytest.raises(Error) as exc:
+        browser_type.launch(**launch_arguments, args=["http://example.com"])
+    assert "can not specify page" in exc.value.message
+
+
+def test_browser_type_launch_should_reject_if_launched_browser_fails_immediately(
+    browser_type: BrowserType, launch_arguments: Dict, assetdir: Path
+) -> None:
+    with pytest.raises(Error):
+        browser_type.launch(
+            **launch_arguments,
+            executable_path=assetdir / "dummy_bad_browser_executable.js",
+        )
+
+
+def test_browser_type_launch_should_reject_if_executable_path_is_invalid(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
+    with pytest.raises(Error) as exc:
+        browser_type.launch(**launch_arguments, executable_path="random-invalid-path")
+    assert "executable doesn't exist" in exc.value.message
+
+
+def test_browser_type_executable_path_should_work(
+    browser_type: BrowserType, browser_channel: str
+) -> None:
+    if browser_channel:
+        return
+    executable_path = browser_type.executable_path
+    assert os.path.exists(executable_path)
+    assert os.path.realpath(executable_path) == os.path.realpath(executable_path)
+
+
+def test_browser_type_name_should_work(
+    browser_type: BrowserType, is_webkit: bool, is_firefox: bool, is_chromium: bool
+) -> None:
+    if is_webkit:
+        assert browser_type.name == "webkit"
+    elif is_firefox:
+        assert browser_type.name == "firefox"
+    elif is_chromium:
+        assert browser_type.name == "chromium"
+    else:
+        raise ValueError("Unknown browser")
+
+
+def test_browser_close_should_fire_close_event_for_all_contexts(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
+    browser = browser_type.launch(**launch_arguments)
+    context = browser.new_context()
+    closed = []
+    context.on("close", lambda _: closed.append(True))
+    browser.close()
+    assert closed == [True]
+
+
+def test_browser_close_should_be_callable_twice(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
+    browser = browser_type.launch(**launch_arguments)
+    browser.close()
+    browser.close()
+
+
+def test_browser_type_launch_should_accept_ignore_default_args_false(
+    browser_type: BrowserType, launch_arguments: Dict
+) -> None:
+    browser = browser_type.launch(**launch_arguments, ignore_default_args=False)
+    browser.close()
diff --git a/tests/sync/test_listeners.py b/tests/sync/test_listeners.py
index 49d766114..56a7afb2f 100644
--- a/tests/sync/test_listeners.py
+++ b/tests/sync/test_listeners.py
@@ -13,10 +13,14 @@
 # limitations under the License.
 
 
-def test_listeners(page, server):
+from playwright.sync_api import Page, Response
+from tests.server import Server
+
+
+def test_listeners(page: Page, server: Server) -> None:
     log = []
 
-    def print_response(response):
+    def print_response(response: Response) -> None:
         log.append(response)
 
     page.on("response", print_response)
diff --git a/tests/sync/test_locator_get_by.py b/tests/sync/test_locator_get_by.py
new file mode 100644
index 000000000..0e5d4396b
--- /dev/null
+++ b/tests/sync/test_locator_get_by.py
@@ -0,0 +1,213 @@
+# 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 re
+
+from playwright.sync_api import Page, expect
+
+
+def test_get_by_test_id(page: Page) -> None:
+    page.set_content("<div><div data-testid='Hello'>Hello world</div></div>")
+    expect(page.get_by_test_id("Hello")).to_have_text("Hello world")
+    expect(page.main_frame.get_by_test_id("Hello")).to_have_text("Hello world")
+    expect(page.locator("div").get_by_test_id("Hello")).to_have_text("Hello world")
+
+
+def test_get_by_test_id_escape_id(page: Page) -> None:
+    page.set_content("<div><div data-testid='He\"llo'>Hello world</div></div>")
+    expect(page.get_by_test_id('He"llo')).to_have_text("Hello world")
+
+
+def test_get_by_text(page: Page) -> None:
+    page.set_content("<div><div>yo</div><div>ya</div><div>\nye  </div></div>")
+
+    expect(page.get_by_text("yo")).to_have_count(1)
+    expect(page.main_frame.get_by_text("yo")).to_have_count(1)
+    expect(page.locator("div").get_by_text("yo")).to_have_count(1)
+
+    assert ">\nye  </div>" in page.get_by_text("ye").evaluate("e => e.outerHTML")
+    assert ">\nye  </div>" in page.get_by_text(r"ye").evaluate("e => e.outerHTML")
+
+    page.set_content("<div> ye </div><div>ye</div>")
+    assert "> ye </div>" in page.get_by_text("ye", exact=True).first.evaluate(
+        "e => e.outerHTML"
+    )
+
+    page.set_content("<div>Hello world</div><div>Hello</div>")
+    assert (
+        page.get_by_text("Hello", exact=True).evaluate("e => e.outerHTML")
+        == "<div>Hello</div>"
+    )
+
+
+def test_get_by_label(page: Page) -> None:
+    page.set_content(
+        "<div><label for=target>Name</label><input id=target type=text></div>"
+    )
+
+    expect(page.get_by_label("Name")).to_have_count(1)
+    expect(page.main_frame.get_by_label("Name")).to_have_count(1)
+    expect(page.locator("div").get_by_label("Name")).to_have_count(1)
+
+    assert page.get_by_text("Name").evaluate("e => e.nodeName") == "LABEL"
+    assert page.get_by_label("Name").evaluate("e => e.nodeName") == "INPUT"
+    assert page.main_frame.get_by_label("Name").evaluate("e => e.nodeName") == "INPUT"
+    assert (
+        page.locator("div").get_by_label("Name").evaluate("e => e.nodeName") == "INPUT"
+    )
+
+
+def test_get_by_label_with_nested_elements(page: Page) -> None:
+    page.set_content(
+        "<label for=target>Last <span>Name</span></label><input id=target type=text>"
+    )
+
+    expect(page.get_by_label("last name")).to_have_attribute("id", "target")
+    expect(page.get_by_label("st na")).to_have_attribute("id", "target")
+    expect(page.get_by_label("Name")).to_have_attribute("id", "target")
+    expect(page.get_by_label("Last Name", exact=True)).to_have_attribute("id", "target")
+    expect(
+        page.get_by_label(re.compile(r"Last\s+name", re.IGNORECASE))
+    ).to_have_attribute("id", "target")
+
+    expect(page.get_by_label("Last", exact=True)).to_have_count(0)
+    expect(page.get_by_label("last name", exact=True)).to_have_count(0)
+    expect(page.get_by_label("Name", exact=True)).to_have_count(0)
+    expect(page.get_by_label("what?")).to_have_count(0)
+    expect(page.get_by_label(re.compile(r"last name"))).to_have_count(0)
+
+
+def test_get_by_placeholder(page: Page) -> None:
+    page.set_content(
+        """<div>
+    <input placeholder="Hello">
+    <input placeholder="Hello World">
+  </div>"""
+    )
+
+    expect(page.get_by_placeholder("hello")).to_have_count(2)
+    expect(page.main_frame.get_by_placeholder("hello")).to_have_count(2)
+    expect(page.locator("div").get_by_placeholder("hello")).to_have_count(2)
+
+    expect(page.get_by_placeholder("hello")).to_have_count(2)
+    expect(page.get_by_placeholder("Hello", exact=True)).to_have_count(1)
+    expect(page.get_by_placeholder(re.compile(r"wor", re.IGNORECASE))).to_have_count(1)
+
+    # Coverage
+    expect(page.main_frame.get_by_placeholder("hello")).to_have_count(2)
+    expect(page.locator("div").get_by_placeholder("hello")).to_have_count(2)
+
+
+def test_get_by_alt_text(page: Page) -> None:
+    page.set_content(
+        """<div>
+    <input alt="Hello">
+    <input alt="Hello World">
+  </div>"""
+    )
+
+    expect(page.get_by_alt_text("hello")).to_have_count(2)
+    expect(page.main_frame.get_by_alt_text("hello")).to_have_count(2)
+    expect(page.locator("div").get_by_alt_text("hello")).to_have_count(2)
+
+    expect(page.get_by_alt_text("hello")).to_have_count(2)
+    expect(page.get_by_alt_text("Hello", exact=True)).to_have_count(1)
+    expect(page.get_by_alt_text(re.compile(r"wor", re.IGNORECASE))).to_have_count(1)
+
+    # Coverage
+    expect(page.main_frame.get_by_alt_text("hello")).to_have_count(2)
+    expect(page.locator("div").get_by_alt_text("hello")).to_have_count(2)
+
+
+def test_get_by_title(page: Page) -> None:
+    page.set_content(
+        """<div>
+    <input title="Hello">
+    <input title="Hello World">
+  </div>"""
+    )
+
+    expect(page.get_by_title("hello")).to_have_count(2)
+    expect(page.main_frame.get_by_title("hello")).to_have_count(2)
+    expect(page.locator("div").get_by_title("hello")).to_have_count(2)
+
+    expect(page.get_by_title("hello")).to_have_count(2)
+    expect(page.get_by_title("Hello", exact=True)).to_have_count(1)
+    expect(page.get_by_title(re.compile(r"wor", re.IGNORECASE))).to_have_count(1)
+
+    # Coverage
+    expect(page.main_frame.get_by_title("hello")).to_have_count(2)
+    expect(page.locator("div").get_by_title("hello")).to_have_count(2)
+
+
+def test_get_by_escaping(page: Page) -> None:
+    page.set_content(
+        """<label id=label for=control>Hello my
+wo"rld</label><input id=control />"""
+    )
+    page.locator("input").evaluate(
+        """input => {
+    input.setAttribute('placeholder', 'hello my\\nwo"rld');
+    input.setAttribute('title', 'hello my\\nwo"rld');
+    input.setAttribute('alt', 'hello my\\nwo"rld');
+  }"""
+    )
+    expect(page.get_by_text('hello my\nwo"rld')).to_have_attribute("id", "label")
+    expect(page.get_by_text('hello     my         wo"rld')).to_have_attribute(
+        "id", "label"
+    )
+    expect(page.get_by_label('hello my\nwo"rld')).to_have_attribute("id", "control")
+    expect(page.get_by_placeholder('hello my\nwo"rld')).to_have_attribute(
+        "id", "control"
+    )
+    expect(page.get_by_alt_text('hello my\nwo"rld')).to_have_attribute("id", "control")
+    expect(page.get_by_title('hello my\nwo"rld')).to_have_attribute("id", "control")
+
+    page.set_content(
+        """<label id=label for=control>Hello my
+world</label><input id=control />"""
+    )
+    page.locator("input").evaluate(
+        """input => {
+    input.setAttribute('placeholder', 'hello my\\nworld');
+    input.setAttribute('title', 'hello my\\nworld');
+    input.setAttribute('alt', 'hello my\\nworld');
+  }"""
+    )
+    expect(page.get_by_text("hello my\nworld")).to_have_attribute("id", "label")
+    expect(page.get_by_text("hello      my       world")).to_have_attribute(
+        "id", "label"
+    )
+    expect(page.get_by_label("hello my\nworld")).to_have_attribute("id", "control")
+    expect(page.get_by_placeholder("hello my\nworld")).to_have_attribute(
+        "id", "control"
+    )
+    expect(page.get_by_alt_text("hello my\nworld")).to_have_attribute("id", "control")
+    expect(page.get_by_title("hello my\nworld")).to_have_attribute("id", "control")
+
+
+def test_get_by_role(page: Page) -> None:
+    page.set_content(
+        """
+    <button>Hello</button>
+    <button>Hel"lo</button>
+    <div role="dialog">I am a dialog</div>
+  """
+    )
+    expect(page.get_by_role("button", name="hello")).to_have_count(1)
+    expect(page.get_by_role("button", name='Hel"lo')).to_have_count(1)
+    expect(
+        page.get_by_role("button", name=re.compile(r"he", re.IGNORECASE))
+    ).to_have_count(2)
+    expect(page.get_by_role("dialog")).to_have_count(1)
diff --git a/tests/sync/test_locators.py b/tests/sync/test_locators.py
new file mode 100644
index 000000000..6201d64db
--- /dev/null
+++ b/tests/sync/test_locators.py
@@ -0,0 +1,1107 @@
+# 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 os
+import re
+import traceback
+from typing import Callable
+from urllib.parse import urlparse
+
+import pytest
+
+from playwright._impl._path_utils import get_file_dirname
+from playwright.sync_api import Error, Locator, Page, expect
+from tests.server import Server
+
+_dirname = get_file_dirname()
+FILE_TO_UPLOAD = _dirname / ".." / "assets/file-to-upload.txt"
+
+
+def test_locators_click_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    button = page.locator("button")
+    button.click()
+    assert page.evaluate("window['result']") == "Clicked"
+
+
+def test_locators_click_should_work_with_node_removed(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    page.evaluate("delete window['Node']")
+    button = page.locator("button")
+    button.click()
+    assert page.evaluate("window['result']") == "Clicked"
+
+
+def test_locators_click_should_work_for_text_nodes(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    page.evaluate(
+        """() => {
+        window['double'] = false;
+        const button = document.querySelector('button');
+        button.addEventListener('dblclick', event => {
+        window['double'] = true;
+        });
+    }"""
+    )
+    button = page.locator("button")
+    button.dblclick()
+    assert page.evaluate("double") is True
+    assert page.evaluate("result") == "Clicked"
+
+
+def test_locators_should_have_repr(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    button = page.locator("button")
+    button.click()
+    assert (
+        str(button)
+        == f"<Locator frame=<Frame name= url='{server.PREFIX}/input/button.html'> selector='button'>"
+    )
+
+
+def test_locators_get_attribute_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/dom.html")
+    button = page.locator("#outer")
+    assert button.get_attribute("name") == "value"
+    assert button.get_attribute("foo") is None
+
+
+def test_locators_input_value_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/dom.html")
+    page.fill("#textarea", "input value")
+    text_area = page.locator("#textarea")
+    assert text_area.input_value() == "input value"
+
+
+def test_locators_inner_html_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/dom.html")
+    locator = page.locator("#outer")
+    assert locator.inner_html() == '<div id="inner">Text,\nmore text</div>'
+
+
+def test_locators_inner_text_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/dom.html")
+    locator = page.locator("#inner")
+    assert locator.inner_text() == "Text, more text"
+
+
+def test_locators_text_content_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/dom.html")
+    locator = page.locator("#inner")
+    assert locator.text_content() == "Text,\nmore text"
+
+
+def test_locators_is_hidden_and_is_visible_should_work(page: Page) -> None:
+    page.set_content("<div>Hi</div><span></span>")
+
+    div = page.locator("div")
+    assert div.is_visible() is True
+    assert div.is_hidden() is False
+
+    span = page.locator("span")
+    assert span.is_visible() is False
+    assert span.is_hidden() is True
+
+
+def test_locators_is_enabled_and_is_disabled_should_work(page: Page) -> None:
+    page.set_content(
+        """
+        <button disabled>button1</button>
+        <button>button2</button>
+        <div>div</div>
+    """
+    )
+
+    div = page.locator("div")
+    assert div.is_enabled()
+    assert div.is_disabled() is False
+
+    button1 = page.locator(':text("button1")')
+    assert button1.is_enabled() is False
+    assert button1.is_disabled() is True
+
+    button1 = page.locator(':text("button2")')
+    assert button1.is_enabled()
+    assert button1.is_disabled() is False
+
+
+def test_locators_is_editable_should_work(page: Page) -> None:
+    page.set_content(
+        """
+        <input id=input1 disabled><textarea></textarea><input id=input2>
+    """
+    )
+
+    input1 = page.locator("#input1")
+    assert input1.is_editable() is False
+
+    input2 = page.locator("#input2")
+    assert input2.is_editable() is True
+
+
+def test_locators_is_checked_should_work(page: Page) -> None:
+    page.set_content(
+        """
+        <input type='checkbox' checked><div>Not a checkbox</div>
+    """
+    )
+
+    element = page.locator("input")
+    assert element.is_checked() is True
+    element.evaluate("e => e.checked = false")
+    assert element.is_checked() is False
+
+
+def test_locators_all_text_contents_should_work(page: Page) -> None:
+    page.set_content(
+        """
+        <div>A</div><div>B</div><div>C</div>
+    """
+    )
+
+    element = page.locator("div")
+    assert element.all_text_contents() == ["A", "B", "C"]
+
+
+def test_locators_all_inner_texts(page: Page) -> None:
+    page.set_content(
+        """
+        <div>A</div><div>B</div><div>C</div>
+    """
+    )
+
+    element = page.locator("div")
+    assert element.all_inner_texts() == ["A", "B", "C"]
+
+
+def test_locators_should_query_existing_element(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/playground.html")
+    page.set_content(
+        """<html><body><div class="second"><div class="inner">A</div></div></body></html>"""
+    )
+    html = page.locator("html")
+    second = html.locator(".second")
+    inner = second.locator(".inner")
+    assert page.evaluate("e => e.textContent", inner.element_handle()) == "A"
+
+
+def test_locators_evaluate_handle_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/dom.html")
+    outer = page.locator("#outer")
+    inner = outer.locator("#inner")
+    check = inner.locator("#check")
+    text = inner.evaluate_handle("e => e.firstChild")
+    page.evaluate("1 + 1")
+    assert (
+        str(outer)
+        == f"<Locator frame=<Frame name= url='{server.PREFIX}/dom.html'> selector='#outer'>"
+    )
+    assert (
+        str(inner)
+        == f"<Locator frame=<Frame name= url='{server.PREFIX}/dom.html'> selector='#outer >> #inner'>"
+    )
+    assert str(text) == "JSHandle@#text=Text,↵more text"
+    assert (
+        str(check)
+        == f"<Locator frame=<Frame name= url='{server.PREFIX}/dom.html'> selector='#outer >> #inner >> #check'>"
+    )
+
+
+def test_locators_should_query_existing_elements(page: Page) -> None:
+    page.set_content("""<html><body><div>A</div><br/><div>B</div></body></html>""")
+    html = page.locator("html")
+    elements = html.locator("div").element_handles()
+    assert len(elements) == 2
+    result = []
+    for element in elements:
+        result.append(page.evaluate("e => e.textContent", element))
+    assert result == ["A", "B"]
+
+
+def test_locators_return_empty_array_for_non_existing_elements(page: Page) -> None:
+    page.set_content("""<html><body><div>A</div><br/><div>B</div></body></html>""")
+    html = page.locator("html")
+    elements = html.locator("abc").element_handles()
+    assert len(elements) == 0
+    assert elements == []
+
+
+def test_locators_evaluate_all_should_work(page: Page) -> None:
+    page.set_content(
+        """<html><body><div class="tweet"><div class="like">100</div><div class="like">10</div></div></body></html>"""
+    )
+    tweet = page.locator(".tweet .like")
+    content = tweet.evaluate_all("nodes => nodes.map(n => n.innerText)")
+    assert content == ["100", "10"]
+
+
+def test_locators_evaluate_all_should_work_with_missing_selector(page: Page) -> None:
+    page.set_content("""<div class="a">not-a-child-div</div><div id="myId"></div""")
+    tweet = page.locator("#myId .a")
+    nodes_length = tweet.evaluate_all("nodes => nodes.length")
+    assert nodes_length == 0
+
+
+def test_locators_hover_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/scrollable.html")
+    button = page.locator("#button-6")
+    button.hover()
+    assert page.evaluate("document.querySelector('button:hover').id") == "button-6"
+
+
+def test_locators_fill_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/textarea.html")
+    button = page.locator("input")
+    button.fill("some value")
+    assert page.evaluate("result") == "some value"
+
+
+def test_locators_clear_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/textarea.html")
+    button = page.locator("input")
+    button.fill("some value")
+    assert page.evaluate("result") == "some value"
+    button.clear()
+    assert page.evaluate("result") == ""
+
+
+def test_locators_check_should_work(page: Page) -> None:
+    page.set_content("<input id='checkbox' type='checkbox'></input>")
+    button = page.locator("input")
+    button.check()
+    assert page.evaluate("checkbox.checked") is True
+
+
+def test_locators_uncheck_should_work(page: Page) -> None:
+    page.set_content("<input id='checkbox' type='checkbox' checked></input>")
+    button = page.locator("input")
+    button.uncheck()
+    assert page.evaluate("checkbox.checked") is False
+
+
+def test_locators_select_option_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    select = page.locator("select")
+    select.select_option("blue")
+    assert page.evaluate("result.onInput") == ["blue"]
+    assert page.evaluate("result.onChange") == ["blue"]
+
+
+def test_locators_focus_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    button = page.locator("button")
+    assert button.evaluate("button => document.activeElement === button") is False
+    button.focus()
+    assert button.evaluate("button => document.activeElement === button") is True
+
+
+def test_locators_dispatch_event_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    button = page.locator("button")
+    button.dispatch_event("click")
+    assert page.evaluate("result") == "Clicked"
+
+
+def test_locators_should_upload_a_file(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/fileupload.html")
+    input = page.locator("input[type=file]")
+
+    file_path = os.path.relpath(FILE_TO_UPLOAD, os.getcwd())
+    input.set_input_files(file_path)
+    assert (
+        page.evaluate("e => e.files[0].name", input.element_handle())
+        == "file-to-upload.txt"
+    )
+
+
+def test_locators_upload_nonexistant_file(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/fileupload.html")
+    with pytest.raises(FileNotFoundError):
+        page.locator("input[type=file]").set_input_files("nonexistant.html")
+
+
+def test_locators_should_press(page: Page) -> None:
+    page.set_content("<input type='text' />")
+    page.locator("input").press("h")
+    assert page.eval_on_selector("input", "input => input.value") == "h"
+
+
+def test_locators_should_scroll_into_view(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/offscreenbuttons.html")
+    for i in range(11):
+        button = page.locator(f"#btn{i}")
+        before = button.evaluate(
+            "button => button.getBoundingClientRect().right - window.innerWidth"
+        )
+        assert before == 10 * i
+        button.scroll_into_view_if_needed()
+        after = button.evaluate(
+            "button => button.getBoundingClientRect().right - window.innerWidth"
+        )
+        assert after <= 0
+        page.evaluate("window.scrollTo(0, 0)")
+
+
+def test_locators_should_select_textarea(
+    page: Page, server: Server, browser_name: str
+) -> None:
+    page.goto(server.PREFIX + "/input/textarea.html")
+    textarea = page.locator("textarea")
+    textarea.evaluate("textarea => textarea.value = 'some value'")
+    textarea.select_text()
+    textarea.select_text(timeout=25_000)
+    if browser_name == "firefox" or browser_name == "webkit":
+        assert textarea.evaluate("el => el.selectionStart") == 0
+        assert textarea.evaluate("el => el.selectionEnd") == 10
+    else:
+        assert page.evaluate("window.getSelection().toString()") == "some value"
+
+
+def test_locators_should_type(page: Page) -> None:
+    page.set_content("<input type='text' />")
+    page.locator("input").type("hello")
+    assert page.eval_on_selector("input", "input => input.value") == "hello"
+
+
+def test_locators_should_screenshot(
+    page: Page, server: Server, assert_to_be_golden: Callable[[bytes, str], None]
+) -> None:
+    page.set_viewport_size(
+        {
+            "width": 500,
+            "height": 500,
+        }
+    )
+    page.goto(server.PREFIX + "/grid.html")
+    page.evaluate("window.scrollBy(50, 100)")
+    element = page.locator(".box:nth-of-type(3)")
+    assert_to_be_golden(element.screenshot(), "screenshot-element-bounding-box.png")
+    assert_to_be_golden(
+        element.screenshot(timeout=1_000), "screenshot-element-bounding-box.png"
+    )
+
+
+def test_locators_should_return_bounding_box(page: Page, server: Server) -> None:
+    page.set_viewport_size(
+        {
+            "width": 500,
+            "height": 500,
+        }
+    )
+    page.goto(server.PREFIX + "/grid.html")
+    element = page.locator(".box:nth-of-type(13)")
+    box = element.bounding_box()
+    assert box == {
+        "x": 100,
+        "y": 50,
+        "width": 50,
+        "height": 50,
+    }
+
+
+def test_locators_should_respect_first_and_last(page: Page) -> None:
+    page.set_content(
+        """
+        <section>
+            <div><p>A</p></div>
+            <div><p>A</p><p>A</p></div>
+            <div><p>A</p><p>A</p><p>A</p></div>
+        </section>"""
+    )
+    assert page.locator("div >> p").count() == 6
+    assert page.locator("div").locator("p").count() == 6
+    assert page.locator("div").first.locator("p").count() == 1
+    assert page.locator("div").last.locator("p").count() == 3
+
+
+def test_locators_should_respect_nth(page: Page) -> None:
+    page.set_content(
+        """
+    <section>
+        <div><p>A</p></div>
+        <div><p>A</p><p>A</p></div>
+        <div><p>A</p><p>A</p><p>A</p></div>
+    </section>"""
+    )
+    assert page.locator("div >> p").nth(0).count() == 1
+    assert page.locator("div").nth(1).locator("p").count() == 2
+    assert page.locator("div").nth(2).locator("p").count() == 3
+
+
+def test_locators_should_throw_on_capture_without_nth(page: Page) -> None:
+    page.set_content(
+        """
+        <section><div><p>A</p></div></section>
+    """
+    )
+    with pytest.raises(Error, match="Can't query n-th element"):
+        page.locator("*css=div >> p").nth(1).click()
+
+
+def test_locators_should_throw_due_to_strictness(page: Page) -> None:
+    page.set_content(
+        """
+        <div>A</div><div>B</div>
+    """
+    )
+    with pytest.raises(Error, match="strict mode violation"):
+        page.locator("div").is_visible()
+
+
+def test_locators_should_throw_due_to_strictness_2(page: Page) -> None:
+    page.set_content(
+        """
+        <select><option>One</option><option>Two</option></select>
+    """
+    )
+    with pytest.raises(Error, match="strict mode violation"):
+        page.locator("option").evaluate("e => {}")
+
+
+def test_locators_set_checked(page: Page) -> None:
+    page.set_content("`<input id='checkbox' type='checkbox'></input>`")
+    locator = page.locator("input")
+    locator.set_checked(True)
+    assert page.evaluate("checkbox.checked")
+    locator.set_checked(False)
+    assert page.evaluate("checkbox.checked") is False
+
+
+def test_should_combine_visible_with_other_selectors(page: Page) -> None:
+    page.set_content(
+        """<div>
+        <div class="item" style="display: none">Hidden data0</div>
+        <div class="item">visible data1</div>
+        <div class="item" style="display: none">Hidden data1</div>
+        <div class="item">visible data2</div>
+        <div class="item" style="display: none">Hidden data1</div>
+        <div class="item">visible data3</div>
+        </div>
+    """
+    )
+    locator = page.locator(".item >> visible=true").nth(1)
+    expect(locator).to_have_text("visible data2")
+    expect(page.locator(".item >> visible=true >> text=data3")).to_have_text(
+        "visible data3"
+    )
+
+
+def test_should_support_filter_visible(page: Page) -> None:
+    page.set_content(
+        """<div>
+    <div class="item" style="display: none">Hidden data0</div>
+    <div class="item">visible data1</div>
+    <div class="item" style="display: none">Hidden data1</div>
+    <div class="item">visible data2</div>
+    <div class="item" style="display: none">Hidden data2</div>
+    <div class="item">visible data3</div>
+    </div>
+    """
+    )
+    locator = page.locator(".item").filter(visible=True).nth(1)
+    expect(locator).to_have_text("visible data2")
+    expect(
+        page.locator(".item").filter(visible=True).get_by_text("data3")
+    ).to_have_text("visible data3")
+    expect(
+        page.locator(".item").filter(visible=False).get_by_text("data1")
+    ).to_have_text("Hidden data1")
+
+
+def test_locator_count_should_work_with_deleted_map_in_main_world(page: Page) -> None:
+    page.evaluate("Map = 1")
+    page.locator("#searchResultTableDiv .x-grid3-row").count()
+    expect(page.locator("#searchResultTableDiv .x-grid3-row")).to_have_count(0)
+
+
+def test_locator_locator_and_framelocator_locator_should_accept_locator(
+    page: Page,
+) -> None:
+    page.set_content(
+        """
+        <div><input value=outer></div>
+        <iframe srcdoc="<div><input value=inner></div>"></iframe>
+    """
+    )
+
+    input_locator = page.locator("input")
+    assert input_locator.input_value() == "outer"
+    assert page.locator("div").locator(input_locator).input_value() == "outer"
+    assert page.frame_locator("iframe").locator(input_locator).input_value() == "inner"
+    assert (
+        page.frame_locator("iframe").locator("div").locator(input_locator).input_value()
+        == "inner"
+    )
+
+    div_locator = page.locator("div")
+    assert div_locator.locator("input").input_value() == "outer"
+    assert (
+        page.frame_locator("iframe").locator(div_locator).locator("input").input_value()
+        == "inner"
+    )
+
+
+def route_iframe(page: Page) -> None:
+    page.route(
+        "**/empty.html",
+        lambda route: route.fulfill(
+            body='<iframe src="iframe.html" name="frame1"></iframe>',
+            content_type="text/html",
+        ),
+    )
+    page.route(
+        "**/iframe.html",
+        lambda route: route.fulfill(
+            body="""<html>
+          <div>
+            <button>Hello iframe</button>
+            <iframe src="iframe-2.html"></iframe>
+          </div>
+          <span>1</span>
+          <span>2</span>
+        </html>""",
+            content_type="text/html",
+        ),
+    )
+    page.route(
+        "**/iframe-2.html",
+        lambda route: route.fulfill(
+            body="<html><button>Hello nested iframe</button></html>",
+            content_type="text/html",
+        ),
+    )
+
+
+def test_locators_frame_should_work_with_iframe(page: Page, server: Server) -> None:
+    route_iframe(page)
+    page.goto(server.EMPTY_PAGE)
+    button = page.frame_locator("iframe").locator("button")
+    button.wait_for()
+    assert button.inner_text() == "Hello iframe"
+    button.click()
+    assert (
+        repr(page.frame_locator("iframe"))
+        == f"<FrameLocator frame=<Frame name= url='{server.PREFIX}/empty.html'> selector='iframe'>"
+    )
+
+
+def test_locators_frame_should_work_for_nested_iframe(
+    page: Page, server: Server
+) -> None:
+    route_iframe(page)
+    page.goto(server.EMPTY_PAGE)
+    button = page.frame_locator("iframe").frame_locator("iframe").locator("button")
+    button.wait_for()
+    assert button.inner_text() == "Hello nested iframe"
+    button.click()
+
+
+def test_locators_frame_should_work_with_locator_frame_locator(
+    page: Page, server: Server
+) -> None:
+    route_iframe(page)
+    page.goto(server.EMPTY_PAGE)
+    button = page.locator("body").frame_locator("iframe").locator("button")
+    button.wait_for()
+    assert button.inner_text() == "Hello iframe"
+    button.click()
+
+
+def test_locator_content_frame_should_work(page: Page, server: Server) -> None:
+    route_iframe(page)
+    page.goto(server.EMPTY_PAGE)
+    locator = page.locator("iframe")
+    frame_locator = locator.content_frame
+    button = frame_locator.locator("button")
+    assert button.inner_text() == "Hello iframe"
+    expect(button).to_have_text("Hello iframe")
+    button.click()
+
+
+def test_frame_locator_owner_should_work(page: Page, server: Server) -> None:
+    route_iframe(page)
+    page.goto(server.EMPTY_PAGE)
+    frame_locator = page.frame_locator("iframe")
+    locator = frame_locator.owner
+    expect(locator).to_be_visible()
+    assert locator.get_attribute("name") == "frame1"
+
+
+def route_ambiguous(page: Page) -> None:
+    page.route(
+        "**/empty.html",
+        lambda route: route.fulfill(
+            body="""
+        <iframe src="iframe-1.html"></iframe>
+        <iframe src="iframe-2.html"></iframe>
+        <iframe src="iframe-3.html"></iframe>
+    """,
+            content_type="text/html",
+        ),
+    )
+    page.route(
+        "**/iframe-*",
+        lambda route: route.fulfill(
+            body=f"<html><button>Hello from {urlparse(route.request.url).path[1:]}</button></html>",
+            content_type="text/html",
+        ),
+    )
+
+
+def test_locator_frame_locator_should_throw_on_ambiguity(
+    page: Page, server: Server
+) -> None:
+    route_ambiguous(page)
+    page.goto(server.EMPTY_PAGE)
+    button = page.locator("body").frame_locator("iframe").locator("button")
+    with pytest.raises(
+        Error,
+        match=r'.*strict mode violation: locator\("body"\)\.locator\("iframe"\) resolved to 3 elements.*',
+    ):
+        button.wait_for()
+
+
+def test_locator_frame_locator_should_not_throw_on_first_last_nth(
+    page: Page, server: Server
+) -> None:
+    route_ambiguous(page)
+    page.goto(server.EMPTY_PAGE)
+    button1 = page.locator("body").frame_locator("iframe").first.locator("button")
+    assert button1.text_content() == "Hello from iframe-1.html"
+    button2 = page.locator("body").frame_locator("iframe").nth(1).locator("button")
+    assert button2.text_content() == "Hello from iframe-2.html"
+    button3 = page.locator("body").frame_locator("iframe").last.locator("button")
+    assert button3.text_content() == "Hello from iframe-3.html"
+
+
+def test_drag_to(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/drag-n-drop.html")
+    page.locator("#source").drag_to(page.locator("#target"))
+    assert (
+        page.eval_on_selector(
+            "#target", "target => target.contains(document.querySelector('#source'))"
+        )
+        is True
+    )
+
+
+def test_locator_query_should_filter_by_text(page: Page, server: Server) -> None:
+    page.set_content("<div>Foobar</div><div>Bar</div>")
+    expect(page.locator("div", has_text="Foo")).to_have_text("Foobar")
+
+
+def test_locator_query_should_filter_by_text_2(page: Page, server: Server) -> None:
+    page.set_content("<div>foo <span>hello world</span> bar</div>")
+    expect(page.locator("div", has_text="hello world")).to_have_text(
+        "foo hello world bar"
+    )
+
+
+def test_locator_query_should_filter_by_regex(page: Page, server: Server) -> None:
+    page.set_content("<div>Foobar</div><div>Bar</div>")
+    expect(page.locator("div", has_text=re.compile(r"Foo.*"))).to_have_text("Foobar")
+
+
+def test_locator_query_should_filter_by_text_with_quotes(
+    page: Page, server: Server
+) -> None:
+    page.set_content('<div>Hello "world"</div><div>Hello world</div>')
+    expect(page.locator("div", has_text='Hello "world"')).to_have_text('Hello "world"')
+
+
+def test_locator_query_should_filter_by_regex_with_quotes(
+    page: Page, server: Server
+) -> None:
+    page.set_content('<div>Hello "world"</div><div>Hello world</div>')
+    expect(page.locator("div", has_text=re.compile('Hello "world"'))).to_have_text(
+        'Hello "world"'
+    )
+
+
+def test_locator_query_should_filter_by_regex_and_regexp_flags(
+    page: Page, server: Server
+) -> None:
+    page.set_content('<div>Hello "world"</div><div>Hello world</div>')
+    expect(
+        page.locator("div", has_text=re.compile('hElLo "world', re.IGNORECASE))
+    ).to_have_text('Hello "world"')
+
+
+def test_locator_should_return_page(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/frames/two-frames.html")
+    outer = page.locator("#outer")
+    assert outer.page == page
+
+    inner = outer.locator("#inner")
+    assert inner.page == page
+
+    in_frame = page.frames[1].locator("div")
+    assert in_frame.page == page
+
+
+def test_locator_should_support_has_locator(page: Page, server: Server) -> None:
+    page.set_content("<div><span>hello</span></div><div><span>world</span></div>")
+    expect(page.locator("div", has=page.locator("text=world"))).to_have_count(1)
+    assert (
+        page.locator("div", has=page.locator("text=world")).evaluate("e => e.outerHTML")
+        == "<div><span>world</span></div>"
+    )
+    expect(page.locator("div", has=page.locator('text="hello"'))).to_have_count(1)
+    assert (
+        page.locator("div", has=page.locator('text="hello"')).evaluate(
+            "e => e.outerHTML"
+        )
+        == "<div><span>hello</span></div>"
+    )
+    expect(page.locator("div", has=page.locator("xpath=./span"))).to_have_count(2)
+    expect(page.locator("div", has=page.locator("span"))).to_have_count(2)
+    expect(page.locator("div", has=page.locator("span", has_text="wor"))).to_have_count(
+        1
+    )
+    assert (
+        page.locator("div", has=page.locator("span", has_text="wor")).evaluate(
+            "e => e.outerHTML"
+        )
+        == "<div><span>world</span></div>"
+    )
+    expect(
+        page.locator(
+            "div",
+            has=page.locator("span"),
+            has_text="wor",
+        )
+    ).to_have_count(1)
+
+
+def test_locator_should_enforce_same_frame_for_has_locator(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.PREFIX + "/frames/two-frames.html")
+    child = page.frames[1]
+    with pytest.raises(Error) as exc_info:
+        page.locator("div", has=child.locator("span"))
+    assert (
+        'Inner "has" locator must belong to the same frame.' in exc_info.value.message
+    )
+
+
+def test_locator_should_support_locator_or(page: Page, server: Server) -> None:
+    page.set_content("<div>hello</div><span>world</span>")
+    expect(page.locator("div").or_(page.locator("span"))).to_have_count(2)
+    expect(page.locator("div").or_(page.locator("span"))).to_have_text(
+        ["hello", "world"]
+    )
+    expect(
+        page.locator("span").or_(page.locator("article")).or_(page.locator("div"))
+    ).to_have_text(["hello", "world"])
+    expect(page.locator("article").or_(page.locator("someting"))).to_have_count(0)
+    expect(page.locator("article").or_(page.locator("div"))).to_have_text("hello")
+    expect(page.locator("article").or_(page.locator("span"))).to_have_text("world")
+    expect(page.locator("div").or_(page.locator("article"))).to_have_text("hello")
+    expect(page.locator("span").or_(page.locator("article"))).to_have_text("world")
+
+
+def test_locator_highlight_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/grid.html")
+    page.locator(".box").nth(3).highlight()
+    assert page.locator("x-pw-glass").is_visible()
+
+
+def test_should_support_locator_that(page: Page) -> None:
+    page.set_content(
+        "<section><div><span>hello</span></div><div><span>world</span></div></section>"
+    )
+
+    expect(page.locator("div").filter(has_text="hello")).to_have_count(1)
+    expect(
+        page.locator("div", has_text="hello").filter(has_text="hello")
+    ).to_have_count(1)
+    expect(
+        page.locator("div", has_text="hello").filter(has_text="world")
+    ).to_have_count(0)
+    expect(
+        page.locator("section", has_text="hello").filter(has_text="world")
+    ).to_have_count(1)
+    expect(page.locator("div").filter(has_text="hello").locator("span")).to_have_count(
+        1
+    )
+    expect(
+        page.locator("div").filter(has=page.locator("span", has_text="world"))
+    ).to_have_count(1)
+    expect(page.locator("div").filter(has=page.locator("span"))).to_have_count(2)
+    expect(
+        page.locator("div").filter(
+            has=page.locator("span"),
+            has_text="world",
+        )
+    ).to_have_count(1)
+
+
+def test_should_filter_by_case_insensitive_regex_in_a_child(page: Page) -> None:
+    page.set_content('<div class="test"><h5>Title Text</h5></div>')
+    expect(
+        page.locator("div", has_text=re.compile(r"^title text$", re.I))
+    ).to_have_text("Title Text")
+
+
+def test_should_filter_by_case_insensitive_regex_in_multiple_children(
+    page: Page,
+) -> None:
+    page.set_content('<div class="test"><h5>Title</h5> <h2><i>Text</i></h2></div>')
+    expect(
+        page.locator("div", has_text=re.compile(r"^title text$", re.I))
+    ).to_have_class("test")
+
+
+def test_should_filter_by_regex_with_special_symbols(page: Page) -> None:
+    page.set_content(
+        '<div class="test"><h5>First/"and"</h5><h2><i>Second\\</i></h2></div>'
+    )
+    expect(
+        page.locator("div", has_text=re.compile(r'^first\/".*"second\\$', re.S | re.I))
+    ).to_have_class("test")
+
+
+def test_should_support_locator_filter(page: Page) -> None:
+    page.set_content(
+        "<section><div><span>hello</span></div><div><span>world</span></div></section>"
+    )
+
+    expect(page.locator("div").filter(has_text="hello")).to_have_count(1)
+    expect(
+        page.locator("div", has_text="hello").filter(has_text="hello")
+    ).to_have_count(1)
+    expect(
+        page.locator("div", has_text="hello").filter(has_text="world")
+    ).to_have_count(0)
+    expect(
+        page.locator("section", has_text="hello").filter(has_text="world")
+    ).to_have_count(1)
+    expect(page.locator("div").filter(has_text="hello").locator("span")).to_have_count(
+        1
+    )
+    expect(
+        page.locator("div").filter(has=page.locator("span", has_text="world"))
+    ).to_have_count(1)
+    expect(page.locator("div").filter(has=page.locator("span"))).to_have_count(2)
+    expect(
+        page.locator("div").filter(
+            has=page.locator("span"),
+            has_text="world",
+        )
+    ).to_have_count(1)
+    expect(
+        page.locator("div").filter(has_not=page.locator("span", has_text="world"))
+    ).to_have_count(1)
+    expect(page.locator("div").filter(has_not=page.locator("section"))).to_have_count(2)
+    expect(page.locator("div").filter(has_not=page.locator("span"))).to_have_count(0)
+
+    expect(page.locator("div").filter(has_not_text="hello")).to_have_count(1)
+    expect(page.locator("div").filter(has_not_text="foo")).to_have_count(2)
+
+
+def test_locators_should_support_locator_and(page: Page) -> None:
+    page.set_content(
+        """
+        <div data-testid=foo>hello</div><div data-testid=bar>world</div>
+        <span data-testid=foo>hello2</span><span data-testid=bar>world2</span>
+    """
+    )
+    expect(page.locator("div").and_(page.locator("div"))).to_have_count(2)
+    expect(page.locator("div").and_(page.get_by_test_id("foo"))).to_have_text(["hello"])
+    expect(page.locator("div").and_(page.get_by_test_id("bar"))).to_have_text(["world"])
+    expect(page.get_by_test_id("foo").and_(page.locator("div"))).to_have_text(["hello"])
+    expect(page.get_by_test_id("bar").and_(page.locator("span"))).to_have_text(
+        ["world2"]
+    )
+    expect(
+        page.locator("span").and_(page.get_by_test_id(re.compile("bar|foo")))
+    ).to_have_count(2)
+
+
+def test_locators_has_does_not_encode_unicode(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    locators = [
+        page.locator("button", has_text="Драматург"),
+        page.locator("button", has_text=re.compile("Драматург")),
+        page.locator("button", has=page.locator("text=Драматург")),
+    ]
+    for locator in locators:
+        with pytest.raises(Error) as exc_info:
+            locator.click(timeout=1_000)
+        assert "Драматург" in exc_info.value.message
+
+
+def test_locators_should_focus_and_blur_a_button(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/button.html")
+    button = page.locator("button")
+    assert not button.evaluate("button => document.activeElement === button")
+
+    focused = False
+    blurred = False
+
+    def focus_event() -> None:
+        nonlocal focused
+        focused = True
+
+    def blur_event() -> None:
+        nonlocal blurred
+        blurred = True
+
+    page.expose_function("focusEvent", focus_event)
+    page.expose_function("blurEvent", blur_event)
+    button.evaluate(
+        """button => {
+        button.addEventListener('focus', window['focusEvent']);
+        button.addEventListener('blur', window['blurEvent']);
+    }"""
+    )
+
+    button.focus()
+    assert focused
+    assert not blurred
+    assert button.evaluate("button => document.activeElement === button")
+
+    button.blur()
+    assert focused
+    assert blurred
+    assert not button.evaluate("button => document.activeElement === button")
+
+
+def test_locator_all_should_work(page: Page) -> None:
+    page.set_content("<div><p>A</p><p>B</p><p>C</p></div>")
+    texts = []
+    for p in page.locator("p").all():
+        texts.append(p.text_content())
+    assert texts == ["A", "B", "C"]
+
+
+def test_locator_click_timeout_error_should_contain_call_log(page: Page) -> None:
+    with pytest.raises(Error) as exc_info:
+        page.get_by_role("button", name="Hello Python").click(timeout=42)
+    formatted_exception = "".join(
+        traceback.format_exception(type(exc_info.value), value=exc_info.value, tb=None)
+    )
+    assert "Locator.click: Timeout 42ms exceeded." in formatted_exception
+    assert (
+        'waiting for get_by_role("button", name="Hello Python")' in formatted_exception
+    )
+    assert (
+        "During handling of the above exception, another exception occurred"
+        not in formatted_exception
+    )
+
+
+def test_locator_should_ignore_deprecated_is_hidden_and_visible_timeout(
+    page: Page,
+) -> None:
+    page.set_content("<div>foo</div>")
+    div = page.locator("div")
+    assert div.is_hidden(timeout=10) is False
+    assert div.is_visible(timeout=10) is True
+
+
+_DROPZONE_HTML = """
+    <style>#dropzone { width: 300px; height: 200px; border: 2px dashed #888; }</style>
+    <div id="dropzone"></div>
+    <script>
+      window.__dropInfo = null;
+      const zone = document.getElementById('dropzone');
+      zone.addEventListener('dragenter', e => e.preventDefault());
+      zone.addEventListener('dragover', e => e.preventDefault());
+      zone.addEventListener('drop', async e => {
+        e.preventDefault();
+        const files = [];
+        for (const file of e.dataTransfer.files)
+          files.push({ name: file.name, type: file.type, size: file.size, text: await file.text() });
+        const data = {};
+        for (const t of e.dataTransfer.types) {
+          if (t !== 'Files')
+            data[t] = e.dataTransfer.getData(t);
+        }
+        window.__dropInfo = { files, data };
+      });
+    </script>
+"""
+
+
+def _get_drop_info(page: Page) -> dict:
+    handle = page.wait_for_function("() => window.__dropInfo")
+    return handle.json_value()
+
+
+def test_drop_should_drop_a_file_payload(page: Page) -> None:
+    page.set_content(_DROPZONE_HTML)
+    page.locator("#dropzone").drop(
+        {"files": {"name": "note.txt", "mimeType": "text/plain", "buffer": b"hello"}}
+    )
+    info = _get_drop_info(page)
+    assert info == {
+        "files": [
+            {"name": "note.txt", "type": "text/plain", "size": 5, "text": "hello"}
+        ],
+        "data": {},
+    }
+
+
+def test_drop_should_drop_clipboard_like_data(page: Page) -> None:
+    page.set_content(_DROPZONE_HTML)
+    page.locator("#dropzone").drop({"data": {"text/plain": "hello world"}})
+    info = _get_drop_info(page)
+    assert info["files"] == []
+    assert info["data"]["text/plain"] == "hello world"
+
+
+def test_get_by_role_with_description(page: Page) -> None:
+    page.set_content(
+        """
+        <div role="alert" aria-label="Upload successful" aria-description="File doc-2025.pdf was uploaded successfully">Alert 1</div>
+        <div role="alert" aria-label="Upload successful" aria-description="File report-2026.pdf was uploaded successfully">Alert 2</div>
+        <div role="alert" aria-label="Invalid file" aria-description="File demo.doc has an invalid file format">Alert 3</div>
+    """
+    )
+
+    def texts(locator: Locator) -> list:
+        return locator.evaluate_all("els => els.map(e => e.textContent)")
+
+    assert texts(page.get_by_role("alert", description="doc-2025")) == ["Alert 1"]
+    assert texts(page.get_by_role("alert", description="report-2026")) == ["Alert 2"]
+    assert texts(
+        page.get_by_role("alert", name="Upload successful", description="doc-2025")
+    ) == ["Alert 1"]
+    assert texts(page.get_by_role("alert", description="doc-2025", exact=True)) == []
+    assert texts(
+        page.get_by_role(
+            "alert",
+            description="File doc-2025.pdf was uploaded successfully",
+            exact=True,
+        )
+    ) == ["Alert 1"]
+    assert texts(page.get_by_role("alert", description=re.compile(r"report-\d+"))) == [
+        "Alert 2"
+    ]
+    assert texts(
+        page.get_by_role("alert", description=re.compile(r"uploaded successfully$"))
+    ) == ["Alert 1", "Alert 2"]
+
+
+def test_get_by_role_with_description_whitespace_normalization(page: Page) -> None:
+    page.set_content(
+        '<div role="alert" aria-description="File  doc-2025.pdf   was uploaded   successfully">Alert</div>'
+    )
+    assert page.get_by_role(
+        "alert", description="  doc-2025.pdf \n was  uploaded "
+    ).evaluate_all("els => els.map(e => e.textContent)") == ["Alert"]
diff --git a/tests/sync/test_network.py b/tests/sync/test_network.py
new file mode 100644
index 000000000..8c196affb
--- /dev/null
+++ b/tests/sync/test_network.py
@@ -0,0 +1,116 @@
+# 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 pytest
+
+from playwright.sync_api import Browser, Page, Playwright, Route
+from tests.server import Server
+
+
+def test_response_server_addr(page: Page, server: Server) -> None:
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    server_addr = response.server_addr()
+    assert server_addr
+    assert server_addr["port"] == server.PORT
+    assert server_addr["ipAddress"] in ["127.0.0.1", "[::1]"]
+
+
+def test_response_security_details(
+    browser: Browser,
+    https_server: Server,
+    browser_name: str,
+    is_win: bool,
+    is_linux: bool,
+) -> None:
+    if (browser_name == "webkit" and is_linux) or (browser_name == "webkit" and is_win):
+        pytest.skip("https://github.com/microsoft/playwright/issues/6759")
+    page = browser.new_page(ignore_https_errors=True)
+    response = page.goto(https_server.EMPTY_PAGE)
+    assert response
+    response.finished()
+    security_details = response.security_details()
+    assert security_details
+    if browser_name == "webkit" and is_win:
+        assert security_details == {
+            "subjectName": "puppeteer-tests",
+            "validFrom": 1550084863,
+            "validTo": -1,
+        }
+    elif browser_name == "webkit":
+        assert security_details == {
+            "protocol": "TLS 1.3",
+            "subjectName": "puppeteer-tests",
+            "validFrom": 1550084863,
+            "validTo": 33086084863,
+        }
+    else:
+        assert security_details == {
+            "issuer": "puppeteer-tests",
+            "protocol": "TLS 1.3",
+            "subjectName": "puppeteer-tests",
+            "validFrom": 1550084863,
+            "validTo": 33086084863,
+        }
+    page.close()
+
+
+def test_response_security_details_none_without_https(
+    page: Page, server: Server
+) -> None:
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    security_details = response.security_details()
+    assert security_details is None
+
+
+def test_should_fulfill_with_global_fetch_result(
+    page: Page, playwright: Playwright, server: Server
+) -> None:
+    def handle_request(route: Route) -> None:
+        request = playwright.request.new_context()
+        response = request.get(server.PREFIX + "/simple.json")
+        route.fulfill(response=response)
+        request.dispose()
+
+    page.route("**/*", handle_request)
+
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 200
+    assert response.json() == {"foo": "bar"}
+
+
+def test_should_report_if_response_was_from_service_worker(
+    page: Page, server: Server
+) -> None:
+    response = page.goto(server.PREFIX + "/serviceworkers/fetch/sw.html")
+    assert response
+    assert not response.from_service_worker
+    page.evaluate("() => window.activationPromise")
+    with page.expect_response("**/example.txt") as response_info:
+        page.evaluate("() => fetch('/example.txt')")
+    assert response_info.value.from_service_worker
+
+
+@pytest.mark.only_browser("chromium")
+def test_should_report_service_worker_request(page: Page, server: Server) -> None:
+    with page.context.expect_event("serviceworker") as worker_info:
+        page.goto(server.PREFIX + "/serviceworkers/fetch/sw.html")
+        page.evaluate("() => window.activationPromise")
+    with page.context.expect_event(
+        "request", lambda r: r.service_worker is not None
+    ) as request_info:
+        page.evaluate("() => fetch('/example.txt')")
+    assert request_info.value.service_worker == worker_info.value
diff --git a/tests/sync/test_page.py b/tests/sync/test_page.py
new file mode 100644
index 000000000..e29c7cabc
--- /dev/null
+++ b/tests/sync/test_page.py
@@ -0,0 +1,124 @@
+# 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 pytest
+
+from playwright.sync_api import Error, Page
+from tests.server import Server
+
+
+def test_input_value(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/textarea.html")
+
+    page.fill("input", "my-text-content")
+    assert page.input_value("input") == "my-text-content"
+
+    page.fill("input", "")
+    assert page.input_value("input") == ""
+
+
+def test_drag_and_drop_helper_method(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/drag-n-drop.html")
+    page.drag_and_drop("#source", "#target")
+    assert (
+        page.eval_on_selector(
+            "#target", "target => target.contains(document.querySelector('#source'))"
+        )
+        is True
+    )
+
+
+def test_should_check_box_using_set_checked(page: Page) -> None:
+    page.set_content("`<input id='checkbox' type='checkbox'></input>`")
+    page.set_checked("input", True)
+    assert page.evaluate("checkbox.checked") is True
+    page.set_checked("input", False)
+    assert page.evaluate("checkbox.checked") is False
+
+
+def test_should_set_bodysize_and_headersize(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    with page.expect_request("*/**") as request_info:
+        page.evaluate(
+            "() => fetch('./get', { method: 'POST', body: '12345'}).then(r => r.text())"
+        )
+    request = request_info.value
+    sizes = request.sizes()
+    assert sizes["requestBodySize"] == 5
+    assert sizes["requestHeadersSize"] >= 300
+
+
+def test_should_set_bodysize_to_0(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    with page.expect_request("*/**") as request_info:
+        page.evaluate("() => fetch('./get').then(r => r.text())")
+
+    request = request_info.value
+    sizes = request.sizes()
+    assert sizes["requestBodySize"] == 0
+    assert sizes["requestHeadersSize"] >= 200
+
+
+def test_sync_stacks_should_work(page: Page, server: Server) -> None:
+    page.route("**/empty.html", lambda route: route.abort())
+    with pytest.raises(Error) as exc_info:
+        page.goto(server.EMPTY_PAGE)
+    assert exc_info.value.stack
+    assert __file__ in exc_info.value.stack
+
+
+def test_emitted_for_domcontentloaded_and_load(page: Page, server: Server) -> None:
+    with page.expect_event("domcontentloaded") as dom_info:
+        with page.expect_event("load") as load_info:
+            page.goto(server.EMPTY_PAGE)
+    assert isinstance(dom_info.value, Page)
+    assert isinstance(load_info.value, Page)
+
+
+def test_page_pause_should_reset_default_timeouts(
+    page: Page, headless: bool, server: Server
+) -> None:
+    if not headless:
+        pytest.skip()
+
+    page.goto(server.EMPTY_PAGE)
+    page.pause()
+    with pytest.raises(Error, match="Timeout 30000ms exceeded."):
+        page.get_by_text("foo").click()
+
+
+def test_page_pause_should_reset_custom_timeouts(
+    page: Page, headless: bool, server: Server
+) -> None:
+    if not headless:
+        pytest.skip()
+
+    page.set_default_timeout(123)
+    page.set_default_navigation_timeout(456)
+    page.goto(server.EMPTY_PAGE)
+    page.pause()
+    with pytest.raises(Error, match="Timeout 123ms exceeded."):
+        page.get_by_text("foo").click()
+
+    server.set_route("/empty.html", lambda route: None)
+    with pytest.raises(Error, match="Timeout 456ms exceeded."):
+        page.goto(server.EMPTY_PAGE)
+
+
+def test_page_should_ignore_deprecated_is_hidden_and_visible_timeout(
+    page: Page,
+) -> None:
+    page.set_content("<div>foo</div>")
+    assert page.is_hidden("div", timeout=10) is False
+    assert page.is_visible("div", timeout=10) is True
diff --git a/tests/sync/test_page_add_locator_handler.py b/tests/sync/test_page_add_locator_handler.py
new file mode 100644
index 000000000..047b4a775
--- /dev/null
+++ b/tests/sync/test_page_add_locator_handler.py
@@ -0,0 +1,435 @@
+# 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 pytest
+
+from playwright.sync_api import Error, Locator, Page, expect
+from tests.server import Server
+from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
+
+
+def test_should_work(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    before_count = 0
+    after_count = 0
+
+    original_locator = page.get_by_text("This interstitial covers the button")
+
+    def handler(locator: Locator) -> None:
+        assert locator == original_locator
+        nonlocal before_count
+        nonlocal after_count
+        before_count += 1
+        page.locator("#close").click()
+        after_count += 1
+
+    page.add_locator_handler(original_locator, handler)
+
+    for args in [
+        ["mouseover", 1],
+        ["mouseover", 1, "capture"],
+        ["mouseover", 2],
+        ["mouseover", 2, "capture"],
+        ["pointerover", 1],
+        ["pointerover", 1, "capture"],
+        ["none", 1],
+        ["remove", 1],
+        ["hide", 1],
+    ]:
+        page.locator("#aside").hover()
+        before_count = 0
+        after_count = 0
+        page.evaluate(
+            "(args) => { window.clicked = 0; window.setupAnnoyingInterstitial(...args); }",
+            args,
+        )
+        assert before_count == 0
+        assert after_count == 0
+        page.locator("#target").click()
+        assert before_count == args[1]
+        assert after_count == args[1]
+        assert page.evaluate("window.clicked") == 1
+        expect(page.locator("#interstitial")).not_to_be_visible()
+
+
+def test_should_work_with_a_custom_check(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    def handler() -> None:
+        if page.get_by_text("This interstitial covers the button").is_visible():
+            page.locator("#close").click()
+
+    page.add_locator_handler(page.locator("body"), handler, no_wait_after=True)
+
+    for args in [
+        ["mouseover", 2],
+        ["none", 1],
+        ["remove", 1],
+        ["hide", 1],
+    ]:
+        page.locator("#aside").hover()
+        page.evaluate(
+            "(args) => { window.clicked = 0; window.setupAnnoyingInterstitial(...args); }",
+            args,
+        )
+        page.locator("#target").click()
+        assert page.evaluate("window.clicked") == 1
+        expect(page.locator("#interstitial")).not_to_be_visible()
+
+
+def test_should_work_with_keyword_only_handler(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    called = False
+
+    def handler(*, timeout: object = None) -> None:
+        nonlocal called
+        assert timeout is None
+        called = True
+        page.locator("#close").click()
+
+    page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"), handler
+    )
+
+    page.locator("#aside").hover()
+    page.evaluate(
+        '() => { window.clicked = 0; window.setupAnnoyingInterstitial("mouseover", 1); }'
+    )
+    page.locator("#target").click()
+    assert called
+    assert page.evaluate("window.clicked") == 1
+    expect(page.locator("#interstitial")).not_to_be_visible()
+
+
+def test_should_work_with_varargs_handler(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    called = False
+    original_locator = page.get_by_text("This interstitial covers the button")
+
+    def handler(*locators: Locator) -> None:
+        nonlocal called
+        assert locators == (original_locator,)
+        called = True
+        page.locator("#close").click()
+
+    page.add_locator_handler(original_locator, handler)
+
+    page.locator("#aside").hover()
+    page.evaluate(
+        '() => { window.clicked = 0; window.setupAnnoyingInterstitial("mouseover", 1); }'
+    )
+    page.locator("#target").click()
+    assert called
+    assert page.evaluate("window.clicked") == 1
+    expect(page.locator("#interstitial")).not_to_be_visible()
+
+
+def test_should_work_with_locator_hover(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"),
+        lambda: page.locator("#close").click(),
+    )
+
+    page.locator("#aside").hover()
+    page.evaluate(
+        '() => { window.setupAnnoyingInterstitial("pointerover", 1, "capture"); }'
+    )
+    page.locator("#target").hover()
+    expect(page.locator("#interstitial")).not_to_be_visible()
+    assert (
+        page.eval_on_selector(
+            "#target", "e => window.getComputedStyle(e).backgroundColor"
+        )
+        == "rgb(255, 255, 0)"
+    )
+
+
+def test_should_not_work_with_force_true(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"),
+        lambda: page.locator("#close").click(),
+    )
+
+    page.locator("#aside").hover()
+    page.evaluate('() => { window.setupAnnoyingInterstitial("none", 1); }')
+    page.locator("#target").click(force=True, timeout=2000)
+    assert page.locator("#interstitial").is_visible()
+    assert page.evaluate("window.clicked") is None
+
+
+def test_should_throw_when_page_closes(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"), lambda: page.close()
+    )
+
+    page.locator("#aside").hover()
+    page.evaluate(
+        '() => { window.clicked = 0; window.setupAnnoyingInterstitial("mouseover", 1); }'
+    )
+    with pytest.raises(Error) as exc:
+        page.locator("#target").click()
+    assert TARGET_CLOSED_ERROR_MESSAGE in exc.value.message
+
+
+def test_should_throw_when_handler_times_out(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    called = 0
+
+    def handler() -> None:
+        nonlocal called
+        called += 1
+        # Deliberately timeout.
+        try:
+            page.wait_for_timeout(9999999)
+        except Exception:
+            pass
+
+    page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"), handler
+    )
+
+    page.locator("#aside").hover()
+    page.evaluate(
+        '() => { window.clicked = 0; window.setupAnnoyingInterstitial("mouseover", 1); }'
+    )
+    with pytest.raises(Error) as exc:
+        page.locator("#target").click(timeout=3000)
+    assert "Timeout 3000ms exceeded" in exc.value.message
+
+    with pytest.raises(Error) as exc:
+        page.locator("#target").click(timeout=3000)
+    assert "Timeout 3000ms exceeded" in exc.value.message
+
+    # Should not enter the same handler while it is still running.
+    assert called == 1
+
+
+def test_should_work_with_to_be_visible(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+
+    called = 0
+
+    def handler() -> None:
+        nonlocal called
+        called += 1
+        page.locator("#close").click()
+
+    page.add_locator_handler(
+        page.get_by_text("This interstitial covers the button"), handler
+    )
+
+    page.evaluate(
+        '() => { window.clicked = 0; window.setupAnnoyingInterstitial("remove", 1); }'
+    )
+    expect(page.locator("#target")).to_be_visible()
+    expect(page.locator("#interstitial")).not_to_be_visible()
+    assert called == 1
+
+
+def test_should_work_when_owner_frame_detaches(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.evaluate(
+        """
+    () => {
+        const iframe = document.createElement('iframe');
+        iframe.src = 'data:text/html,<body>hello from iframe</body>';
+        document.body.append(iframe);
+
+        const target = document.createElement('button');
+        target.textContent = 'Click me';
+        target.id = 'target';
+        target.addEventListener('click', () => window._clicked = true);
+        document.body.appendChild(target);
+
+        const closeButton = document.createElement('button');
+        closeButton.textContent = 'close';
+        closeButton.id = 'close';
+        closeButton.addEventListener('click', () => iframe.remove());
+        document.body.appendChild(closeButton);
+    }
+    """
+    )
+    page.add_locator_handler(
+        page.frame_locator("iframe").locator("body"),
+        lambda: page.locator("#close").click(),
+    )
+    page.locator("#target").click()
+    assert page.query_selector("iframe") is None
+    assert page.evaluate("window._clicked") is True
+
+
+def test_should_work_with_times_option(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler() -> None:
+        nonlocal called
+        called += 1
+
+    page.add_locator_handler(
+        page.locator("body"), _handler, no_wait_after=True, times=2
+    )
+    page.locator("#aside").hover()
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('mouseover', 4);
+    }
+    """
+    )
+    with pytest.raises(Error) as exc_info:
+        page.locator("#target").click(timeout=3000)
+    assert called == 2
+    assert page.evaluate("window.clicked") == 0
+    expect(page.locator("#interstitial")).to_be_visible()
+    assert "Timeout 3000ms exceeded" in exc_info.value.message
+    assert (
+        '<div>This interstitial covers the button</div> from <div class="visible" id="interstitial">…</div> subtree intercepts pointer events'
+        in exc_info.value.message
+    )
+
+
+def test_should_wait_for_hidden_by_default(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler(button: Locator) -> None:
+        nonlocal called
+        called += 1
+        button.click()
+
+    page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    page.locator("#aside").hover()
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('timeout', 1);
+    }
+    """
+    )
+    page.locator("#target").click()
+    assert page.evaluate("window.clicked") == 1
+    expect(page.locator("#interstitial")).not_to_be_visible()
+    assert called == 1
+
+
+def test_should_wait_for_hidden_by_default_2(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler() -> None:
+        nonlocal called
+        called += 1
+
+    page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    page.locator("#aside").hover()
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    with pytest.raises(Error) as exc_info:
+        page.locator("#target").click(timeout=3000)
+    assert page.evaluate("window.clicked") == 0
+    assert page.locator("#interstitial").is_visible()
+    assert called == 1
+    assert (
+        'locator handler has finished, waiting for get_by_role("button", name="close") to be hidden'
+        in exc_info.value.message
+    )
+
+
+def test_should_work_with_noWaitAfter(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler(button: Locator) -> None:
+        nonlocal called
+        called += 1
+        if called == 1:
+            button.click()
+        else:
+            page.locator("#interstitial").wait_for(state="hidden")
+
+    page.add_locator_handler(
+        page.get_by_role("button", name="close"), _handler, no_wait_after=True
+    )
+    page.locator("#aside").hover()
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('timeout', 1);
+    }
+    """
+    )
+    page.locator("#target").click()
+    assert page.evaluate("window.clicked") == 1
+    expect(page.locator("#interstitial")).not_to_be_visible()
+    assert called == 2
+
+
+def test_should_removeLocatorHandler(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/input/handle-locator.html")
+    called = 0
+
+    def _handler(locator: Locator) -> None:
+        nonlocal called
+        called += 1
+        locator.click()
+
+    page.add_locator_handler(page.get_by_role("button", name="close"), _handler)
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    page.locator("#target").click()
+    assert called == 1
+    assert page.evaluate("window.clicked") == 1
+    expect(page.locator("#interstitial")).not_to_be_visible()
+    page.evaluate(
+        """
+    () => {
+        window.clicked = 0;
+        window.setupAnnoyingInterstitial('hide', 1);
+    }
+    """
+    )
+    page.remove_locator_handler(page.get_by_role("button", name="close"))
+    with pytest.raises(Error) as error:
+        page.locator("#target").click(timeout=3000)
+    assert called == 1
+    assert page.evaluate("window.clicked") == 0
+    expect(page.locator("#interstitial")).to_be_visible()
+    assert "Timeout 3000ms exceeded" in error.value.message
diff --git a/tests/sync/test_page_aria_snapshot.py b/tests/sync/test_page_aria_snapshot.py
new file mode 100644
index 000000000..03b59dfe6
--- /dev/null
+++ b/tests/sync/test_page_aria_snapshot.py
@@ -0,0 +1,274 @@
+# 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 re
+
+import pytest
+
+from playwright.sync_api import Locator, Page, expect
+
+
+def _unshift(snapshot: str) -> str:
+    lines = snapshot.split("\n")
+    whitespace_prefix_length = 100
+    for line in lines:
+        if not line.strip():
+            continue
+        match = re.match(r"^(\s*)", line)
+        if match and len(match[1]) < whitespace_prefix_length:
+            whitespace_prefix_length = len(match[1])
+    return "\n".join(
+        [line[whitespace_prefix_length:] for line in lines if line.strip()]
+    )
+
+
+def check_and_match_snapshot(locator: Locator, snapshot: str) -> None:
+    assert locator.aria_snapshot() == _unshift(snapshot)
+    expect(locator).to_match_aria_snapshot(snapshot)
+
+
+def test_should_snapshot(page: Page) -> None:
+    page.set_content("<h1>title</h1>")
+    check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - heading "title" [level=1]
+    """,
+    )
+
+
+def test_should_snapshot_list(page: Page) -> None:
+    page.set_content("<h1>title</h1><h1>title 2</h1>")
+    check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - heading "title" [level=1]
+      - heading "title 2" [level=1]
+    """,
+    )
+
+
+def test_should_snapshot_list_with_list(page: Page) -> None:
+    page.set_content("<ul><li>one</li><li>two</li></ul>")
+    check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list:
+        - listitem: one
+        - listitem: two
+    """,
+    )
+
+
+def test_should_snapshot_list_with_accessible_name(page: Page) -> None:
+    page.set_content('<ul aria-label="my list"><li>one</li><li>two</li></ul>')
+    check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list "my list":
+        - listitem: one
+        - listitem: two
+    """,
+    )
+
+
+def test_should_snapshot_complex(page: Page) -> None:
+    page.set_content('<ul><li><a href="about:blank">link</a></li></ul>')
+    check_and_match_snapshot(
+        page.locator("body"),
+        """
+      - list:
+        - listitem:
+          - link "link":
+            - /url: about:blank
+    """,
+    )
+
+
+def test_should_snapshot_with_unexpected_children_equal(page: Page) -> None:
+    page.set_content(
+        """
+      <ul>
+        <li>One</li>
+        <li>Two</li>
+        <li>Three</li>
+      </ul>
+    """
+    )
+    expect(page.locator("body")).to_match_aria_snapshot(
+        """
+      - list:
+        - listitem: One
+        - listitem: Three
+    """,
+    )
+    with pytest.raises(AssertionError):
+        expect(page.locator("body")).to_match_aria_snapshot(
+            """
+        - list:
+          - /children: equal
+          - listitem: One
+          - listitem: Three
+      """,
+            timeout=1000,
+        )
+
+
+def test_should_snapshot_with_unexpected_children_deep_equal(page: Page) -> None:
+    page.set_content(
+        """
+      <ul>
+        <li>
+          <ul>
+            <li>1.1</li>
+            <li>1.2</li>
+          </ul>
+        </li>
+      </ul>
+    """
+    )
+    expect(page.locator("body")).to_match_aria_snapshot(
+        """
+      - list:
+        - listitem:
+          - list:
+            - listitem: 1.1
+    """,
+    )
+    expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - list:
+          - /children: equal
+          - listitem:
+            - list:
+              - listitem: 1.1
+      """,
+    )
+    with pytest.raises(AssertionError):
+        expect(page.locator("body")).to_match_aria_snapshot(
+            """
+          - list:
+            - /children: deep-equal
+            - listitem:
+              - list:
+                - listitem: 1.1
+        """,
+            timeout=1000,
+        )
+
+
+def test_should_snapshot_with_restored_contain_mode_inside_deep_equal(
+    page: Page,
+) -> None:
+    page.set_content(
+        """
+      <ul>
+        <li>
+          <ul>
+            <li>1.1</li>
+            <li>1.2</li>
+          </ul>
+        </li>
+      </ul>
+    """
+    )
+    with pytest.raises(AssertionError):
+        expect(page.locator("body")).to_match_aria_snapshot(
+            """
+        - list:
+          - /children: deep-equal
+          - listitem:
+            - list:
+              - listitem: 1.1
+      """,
+            timeout=1000,
+        )
+    expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - list:
+          - /children: deep-equal
+          - listitem:
+            - list:
+              - /children: contain
+              - listitem: 1.1
+      """,
+    )
+
+
+def test_match_values_both_against_regex_and_string(page: Page) -> None:
+    page.set_content('<a href="/auth?r=/">Log in</a>')
+    expect(page.locator("body")).to_match_aria_snapshot(
+        """
+        - link "Log in":
+          - /url: /auth?r=/
+      """,
+    )
+
+
+def test_should_snapshot_with_depth(page: Page) -> None:
+    page.set_content("<ul><li><a href=about:blank>link</a></li></ul>")
+    snapshot = page.locator("body").aria_snapshot(depth=1)
+    assert "listitem" in snapshot
+    assert "/url" not in snapshot
+
+
+def test_page_aria_snapshot_should_work(page: Page) -> None:
+    page.set_content("<h1>title</h1>")
+    snapshot = page.aria_snapshot()
+    assert _unshift(snapshot) == _unshift(
+        """
+      - heading "title" [level=1]
+    """
+    )
+
+
+def test_to_match_aria_snapshot_should_match_page(page: Page) -> None:
+    page.set_content("<h1>title</h1>")
+    expect(page).to_match_aria_snapshot(
+        """
+        - heading "title"
+        """
+    )
+
+
+def test_to_match_aria_snapshot_should_match_page_complex(page: Page) -> None:
+    page.set_content(
+        """
+        <h1>Microsoft</h1>
+        <div>Open source projects and samples from Microsoft</div>
+        <ul>
+          <li>
+            <a href="about:blank">Playwright</a>
+          </li>
+        </ul>
+        """
+    )
+    expect(page).to_match_aria_snapshot(
+        """
+        - heading "Microsoft"
+        - text: Open source projects and samples from Microsoft
+        - list:
+          - listitem:
+            - link "Playwright"
+        """
+    )
+
+
+def test_to_match_aria_snapshot_should_match_page_with_not(page: Page) -> None:
+    page.set_content("<h1>title</h1>")
+    expect(page).not_to_match_aria_snapshot(
+        """
+        - heading "wrong"
+        """
+    )
diff --git a/tests/sync/test_page_clock.py b/tests/sync/test_page_clock.py
new file mode 100644
index 000000000..72d5e5a3e
--- /dev/null
+++ b/tests/sync/test_page_clock.py
@@ -0,0 +1,470 @@
+# 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 datetime
+from typing import Any, Generator, List
+
+import pytest
+
+from playwright.sync_api import Error, Page
+from tests.server import Server
+
+
+@pytest.fixture(autouse=True)
+def calls(page: Page) -> List[Any]:
+    calls: List[Any] = []
+    page.expose_function("stub", lambda *args: calls.append(list(args)))
+    return calls
+
+
+class TestRunFor:
+    @pytest.fixture(autouse=True)
+    def before_each(self, page: Page) -> Generator[None, None, None]:
+        page.clock.install(time=0)
+        page.clock.pause_at(1000)
+        yield
+
+    def test_run_for_triggers_immediately_without_specified_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(window.stub)")
+        page.clock.run_for(0)
+        assert len(calls) == 1
+
+    def test_run_for_does_not_trigger_without_sufficient_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(window.stub, 100)")
+        page.clock.run_for(10)
+        assert len(calls) == 0
+
+    def test_run_for_triggers_after_sufficient_delay(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(window.stub, 100)")
+        page.clock.run_for(100)
+        assert len(calls) == 1
+
+    def test_run_for_triggers_simultaneous_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(window.stub, 100); setTimeout(window.stub, 100)")
+        page.clock.run_for(100)
+        assert len(calls) == 2
+
+    def test_run_for_triggers_multiple_simultaneous_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate(
+            "setTimeout(window.stub, 100); setTimeout(window.stub, 100); setTimeout(window.stub, 99); setTimeout(window.stub, 100)"
+        )
+        page.clock.run_for(100)
+        assert len(calls) == 4
+
+    def test_run_for_waits_after_setTimeout_was_called(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(window.stub, 150)")
+        page.clock.run_for(50)
+        assert len(calls) == 0
+        page.clock.run_for(100)
+        assert len(calls) == 1
+
+    def test_run_for_triggers_event_when_some_throw(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate(
+            "setTimeout(() => { throw new Error(); }, 100); setTimeout(window.stub, 120)"
+        )
+        with pytest.raises(Error):
+            page.clock.run_for(120)
+        assert len(calls) == 1
+
+    def test_run_for_creates_updated_Date_while_ticking(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.clock.set_system_time(0)
+        page.evaluate("setInterval(() => { window.stub(new Date().getTime()); }, 10)")
+        page.clock.run_for(100)
+        assert calls == [
+            [10],
+            [20],
+            [30],
+            [40],
+            [50],
+            [60],
+            [70],
+            [80],
+            [90],
+            [100],
+        ]
+
+    def test_run_for_passes_8_seconds(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate("setInterval(window.stub, 4000)")
+        page.clock.run_for("08")
+        assert len(calls) == 2
+
+    def test_run_for_passes_1_minute(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate("setInterval(window.stub, 6000)")
+        page.clock.run_for("01:00")
+        assert len(calls) == 10
+
+    def test_run_for_passes_2_hours_34_minutes_and_10_seconds(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setInterval(window.stub, 10000)")
+        page.clock.run_for("02:34:10")
+        assert len(calls) == 925
+
+    def test_run_for_throws_for_invalid_format(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setInterval(window.stub, 10000)")
+        with pytest.raises(Error):
+            page.clock.run_for("12:02:34:10")
+        assert len(calls) == 0
+
+    def test_run_for_returns_the_current_now_value(self, page: Page) -> None:
+        page.clock.set_system_time(0)
+        value = 200
+        page.clock.run_for(value)
+        assert page.evaluate("Date.now()") == value
+
+
+class TestFastForward:
+    @pytest.fixture(autouse=True)
+    def before_each(self, page: Page) -> Generator[None, None, None]:
+        page.clock.install(time=0)
+        page.clock.pause_at(1)
+        yield
+
+    def test_ignores_timers_which_wouldnt_be_run(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate(
+            "setTimeout(() => { window.stub('should not be logged'); }, 1000)"
+        )
+        page.clock.fast_forward(500)
+        assert len(calls) == 0
+
+    def test_pushes_back_execution_time_for_skipped_timers(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.evaluate("setTimeout(() => { window.stub(Date.now()); }, 1000)")
+        page.clock.fast_forward(2000)
+        assert calls == [[1000 + 2000]]
+
+    def test_supports_string_time_arguments(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate(
+            "setTimeout(() => { window.stub(Date.now()); }, 100000)"
+        )  # 100000 = 1:40
+        page.clock.fast_forward("01:50")
+        assert calls == [[1000 + 110000]]
+
+
+class TestStubTimers:
+    @pytest.fixture(autouse=True)
+    def before_each(self, page: Page) -> Generator[None, None, None]:
+        page.clock.install(time=0)
+        page.clock.pause_at(1)
+        yield
+
+    def test_sets_initial_timestamp(self, page: Page) -> None:
+        page.clock.set_system_time(1.4)
+        assert page.evaluate("Date.now()") == 1400
+
+    def test_replaces_global_setTimeout(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate("setTimeout(window.stub, 1000)")
+        page.clock.run_for(1000)
+        assert len(calls) == 1
+
+    def test_global_fake_setTimeout_should_return_id(self, page: Page) -> None:
+        to = page.evaluate("setTimeout(window.stub, 1000)")
+        assert isinstance(to, int)
+
+    def test_replaces_global_clearTimeout(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate(
+            """
+            const to = setTimeout(window.stub, 1000);
+            clearTimeout(to);
+        """
+        )
+        page.clock.run_for(1000)
+        assert len(calls) == 0
+
+    def test_replaces_global_setInterval(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate("setInterval(window.stub, 500)")
+        page.clock.run_for(1000)
+        assert len(calls) == 2
+
+    def test_replaces_global_clearInterval(self, page: Page, calls: List[Any]) -> None:
+        page.evaluate(
+            """
+            const to = setInterval(window.stub, 500);
+            clearInterval(to);
+        """
+        )
+        page.clock.run_for(1000)
+        assert len(calls) == 0
+
+    def test_replaces_global_performance_now(self, page: Page) -> None:
+        page.evaluate(
+            """() => {
+            window.waitForPromise = new Promise(async resolve => {
+                const prev = performance.now();
+                await new Promise(f => setTimeout(f, 1000));
+                const next = performance.now();
+                resolve({ prev, next });
+            });
+        }"""
+        )
+        page.clock.run_for(1000)
+        assert page.evaluate("window.waitForPromise") == {"prev": 1000, "next": 2000}
+
+    def test_fakes_Date_constructor(self, page: Page) -> None:
+        now = page.evaluate("new Date().getTime()")
+        assert now == 1000
+
+
+class TestStubTimersPerformance:
+    def test_replaces_global_performance_time_origin(self, page: Page) -> None:
+        page.clock.install(time=1)
+        page.clock.pause_at(2)
+        page.evaluate(
+            """() => {
+            window.waitForPromise = new Promise(async resolve => {
+                const prev = performance.now();
+                await new Promise(f => setTimeout(f, 1000));
+                const next = performance.now();
+                resolve({ prev, next });
+            });
+        }"""
+        )
+        page.clock.run_for(1000)
+        assert page.evaluate("performance.timeOrigin") == 1000
+        assert page.evaluate("window.waitForPromise") == {"prev": 1000, "next": 2000}
+
+
+class TestPopup:
+    def test_should_tick_after_popup(self, page: Page) -> None:
+        page.clock.install(time=0)
+        now = datetime.datetime.fromisoformat("2015-09-25")
+        page.clock.pause_at(now)
+        with page.expect_popup() as popup_info:
+            page.evaluate("window.open('about:blank')")
+        popup = popup_info.value
+        popup_time = popup.evaluate("Date.now()")
+        assert popup_time == now.timestamp() * 1000
+        page.clock.run_for(1000)
+        popup_time_after = popup.evaluate("Date.now()")
+        assert popup_time_after == now.timestamp() * 1000 + 1000
+
+    def test_should_tick_before_popup(self, page: Page) -> None:
+        page.clock.install(time=0)
+        now = datetime.datetime.fromisoformat("2015-09-25")
+        page.clock.pause_at(now)
+        page.clock.run_for(1000)
+        with page.expect_popup() as popup_info:
+            page.evaluate("window.open('about:blank')")
+        popup = popup_info.value
+        popup_time = popup.evaluate("Date.now()")
+        assert popup_time == int(now.timestamp() * 1_000 + 1000)
+        assert datetime.datetime.fromtimestamp(popup_time / 1_000).year == 2015
+
+    def test_should_run_time_before_popup(self, page: Page, server: Server) -> None:
+        server.set_route(
+            "/popup.html",
+            lambda res: (
+                res.setHeader("Content-Type", "text/html"),
+                res.write(b"<script>window.time = Date.now()</script>"),
+                res.finish(),
+            ),
+        )
+        page.goto(server.EMPTY_PAGE)
+        # Wait for 2 second in real life to check that it is past in popup.
+        page.wait_for_timeout(2000)
+        with page.expect_popup() as popup_info:
+            page.evaluate("window.open('{}')".format(server.PREFIX + "/popup.html"))
+        popup = popup_info.value
+        popup_time = popup.evaluate("window.time")
+        assert popup_time >= 2000
+
+    def test_should_not_run_time_before_popup_on_pause(
+        self, page: Page, server: Server
+    ) -> None:
+        server.set_route(
+            "/popup.html",
+            lambda res: (
+                res.setHeader("Content-Type", "text/html"),
+                res.write(b"<script>window.time = Date.now()</script>"),
+                res.finish(),
+            ),
+        )
+        page.clock.install(time=0)
+        page.clock.pause_at(1)
+        page.goto(server.EMPTY_PAGE)
+        # Wait for 2 second in real life to check that it is past in popup.
+        page.wait_for_timeout(2000)
+        with page.expect_popup() as popup_info:
+            page.evaluate("window.open('{}')".format(server.PREFIX + "/popup.html"))
+        popup = popup_info.value
+        popup_time = popup.evaluate("window.time")
+        assert popup_time == 1000
+
+
+class TestSetFixedTime:
+    def test_allows_passing_as_int(self, page: Page) -> None:
+        page.clock.set_fixed_time(1)
+        assert page.evaluate("Date.now()") == 1000
+        page.clock.set_fixed_time(int(2))
+        assert page.evaluate("Date.now()") == 2000
+
+    def test_does_not_fake_methods(self, page: Page) -> None:
+        page.clock.set_fixed_time(0)
+        # Should not stall.
+        page.evaluate("new Promise(f => setTimeout(f, 1))")
+
+    def test_allows_setting_time_multiple_times(self, page: Page) -> None:
+        page.clock.set_fixed_time(0.1)
+        assert page.evaluate("Date.now()") == 100
+        page.clock.set_fixed_time(0.2)
+        assert page.evaluate("Date.now()") == 200
+
+    def test_fixed_time_is_not_affected_by_clock_manipulation(self, page: Page) -> None:
+        page.clock.set_fixed_time(0.1)
+        assert page.evaluate("Date.now()") == 100
+        page.clock.fast_forward(20)
+        assert page.evaluate("Date.now()") == 100
+
+    def test_allows_installing_fake_timers_after_setting_time(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.clock.set_fixed_time(0.1)
+        assert page.evaluate("Date.now()") == 100
+        page.clock.set_fixed_time(0.2)
+        page.evaluate("setTimeout(() => window.stub(Date.now()))")
+        page.clock.run_for(0)
+        assert calls == [[200]]
+
+
+class TestWhileRunning:
+    def test_should_progress_time(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.wait_for_timeout(1000)
+        now = page.evaluate("Date.now()")
+        assert 1000 <= now <= 2000
+
+    def test_should_run_for(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.run_for(10000)
+        now = page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    def test_should_fast_forward(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.fast_forward(10000)
+        now = page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    def test_should_fast_forward_to(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.fast_forward(10000)
+        now = page.evaluate("Date.now()")
+        assert 10000 <= now <= 11000
+
+    def test_should_pause(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1)
+        page.wait_for_timeout(1000)
+        now = page.evaluate("Date.now()")
+        assert 0 <= now <= 1000
+
+    def test_should_pause_and_fast_forward(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1)
+        page.clock.fast_forward(1000)
+        now = page.evaluate("Date.now()")
+        assert now == 2000
+
+    def test_should_set_system_time_on_pause(self, page: Page) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1)
+        now = page.evaluate("Date.now()")
+        assert now == 1000
+
+
+class TestWhileOnPause:
+    def test_fast_forward_should_not_run_nested_immediate(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1000)
+        page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                setTimeout(() => window.stub('inner'), 0);
+            }, 1000);
+        """
+        )
+        page.clock.fast_forward(1000)
+        assert calls == [["outer"]]
+        page.clock.fast_forward(1)
+        assert calls == [["outer"], ["inner"]]
+
+    def test_run_for_should_not_run_nested_immediate(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1000)
+        page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                setTimeout(() => window.stub('inner'), 0);
+            }, 1000);
+        """
+        )
+        page.clock.run_for(1000)
+        assert calls == [["outer"]]
+        page.clock.run_for(1)
+        assert calls == [["outer"], ["inner"]]
+
+    def test_run_for_should_not_run_nested_immediate_from_microtask(
+        self, page: Page, calls: List[Any]
+    ) -> None:
+        page.clock.install(time=0)
+        page.goto("data:text/html,")
+        page.clock.pause_at(1000)
+        page.evaluate(
+            """
+            setTimeout(() => {
+                window.stub('outer');
+                void Promise.resolve().then(() => setTimeout(() => window.stub('inner'), 0));
+            }, 1000);
+        """
+        )
+        page.clock.run_for(1000)
+        assert calls == [["outer"]]
+        page.clock.run_for(1)
+        assert calls == [["outer"], ["inner"]]
diff --git a/tests/sync/test_page_event_console.py b/tests/sync/test_page_event_console.py
new file mode 100644
index 000000000..34dd192e4
--- /dev/null
+++ b/tests/sync/test_page_event_console.py
@@ -0,0 +1,49 @@
+# 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.
+
+
+from playwright.sync_api import Page
+
+
+def test_console_messages_should_work(page: Page) -> None:
+    page.evaluate(
+        """() => {
+            for (let i = 0; i < 301; i++)
+                console.log('message' + i);
+        }"""
+    )
+
+    messages = page.console_messages()
+    objects = [{"text": m.text, "type": m.type, "page": m.page} for m in messages]
+
+    expected = []
+    for i in range(201, 301):
+        expected.append({"text": f"message{i}", "type": "log", "page": page})
+
+    assert len(objects) >= 100, "should be at least 100 messages"
+    message_count = len(messages) - len(expected)
+    assert objects[message_count:] == expected, "should return last messages"
+
+
+def test_should_have_a_timestamp(page: Page) -> None:
+    with page.expect_console_message() as message_info:
+        page.evaluate("() => console.log('hello')")
+    assert message_info.value.timestamp > 0
+
+
+def test_clear_console_messages_should_drop_buffered_messages(page: Page) -> None:
+    page.evaluate("() => console.log('first')")
+    assert any(m.text == "first" for m in page.console_messages())
+    page.clear_console_messages()
+    assert not any(m.text == "first" for m in page.console_messages())
diff --git a/tests/sync/test_page_event_pageerror.py b/tests/sync/test_page_event_pageerror.py
new file mode 100644
index 000000000..9295cb1b0
--- /dev/null
+++ b/tests/sync/test_page_event_pageerror.py
@@ -0,0 +1,36 @@
+# 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.
+
+from playwright.sync_api import Page
+
+
+def test_page_errors_should_work(page: Page) -> None:
+    page.evaluate(
+        """async () => {
+            for (let i = 0; i < 301; i++)
+                window.setTimeout(() => { throw new Error('error' + i); }, 0);
+            await new Promise(f => window.setTimeout(f, 100));
+        }"""
+    )
+
+    errors = page.page_errors()
+    messages = [e.message for e in errors]
+
+    expected = []
+    for i in range(201, 301):
+        expected.append(f"error{i}")
+
+    assert len(messages) >= 100, "should be at least 100 errors"
+    message_count = len(messages) - len(expected)
+    assert messages[message_count:] == expected, "should return last errors"
diff --git a/tests/sync/test_page_event_request.py b/tests/sync/test_page_event_request.py
new file mode 100644
index 000000000..77515091f
--- /dev/null
+++ b/tests/sync/test_page_event_request.py
@@ -0,0 +1,54 @@
+# 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.
+
+from playwright.sync_api import Page, Request, Route
+from tests.server import Server
+
+
+def test_should_return_last_requests(page: Page, server: Server) -> None:
+    page.goto(server.PREFIX + "/title.html")
+    for i in range(200):
+
+        def _handle_route(route: Route) -> None:
+            route.fulfill(
+                status=200,
+                body=f"url:{route.request.url}",
+            )
+
+        page.route(f"**/fetch?{i}", _handle_route)
+
+    # #0 is the navigation request, so start with #1.
+    for i in range(1, 100):
+        page.evaluate("url => fetch(url)", server.PREFIX + f"/fetch?{i}")
+    first_100_requests_with_goto = page.requests()
+    first_100_requests = first_100_requests_with_goto[1:]
+
+    for i in range(100, 200):
+        page.evaluate("url => fetch(url)", server.PREFIX + f"/fetch?{i}")
+    last_100_requests = page.requests()
+
+    all_requests = first_100_requests + last_100_requests
+
+    def gather_response(request: Request) -> dict:
+        response = request.response()
+        assert response
+        return {"text": response.text(), "url": request.url}
+
+    # All 199 requests are fully functional.
+    received = [gather_response(request) for request in all_requests]
+    expected = []
+    for i in range(1, 200):
+        url = server.PREFIX + f"/fetch?{i}"
+        expected.append({"url": url, "text": f"url:{url}"})
+    assert received == expected
diff --git a/tests/sync/test_page_network_response.py b/tests/sync/test_page_network_response.py
new file mode 100644
index 000000000..7e11f4501
--- /dev/null
+++ b/tests/sync/test_page_network_response.py
@@ -0,0 +1,72 @@
+# 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 pytest
+from twisted.web import http
+
+from playwright.sync_api import Error, Page
+from tests.server import Server
+
+
+def test_should_reject_response_finished_if_page_closes(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+
+    def handle_get(request: http.Request) -> None:
+        # In Firefox, |fetch| will be hanging until it receives |Content-Type| header
+        # from server.
+        request.setHeader("Content-Type", "text/plain; charset=utf-8")
+        request.write(b"hello ")
+
+    server.set_route("/get", handle_get)
+    # send request and wait for server response
+    with page.expect_response("**/*") as response_info:
+        page.evaluate("() => fetch('./get', { method: 'GET' })")
+    page_response = response_info.value
+    page.close()
+    with pytest.raises(Error) as exc_info:
+        page_response.finished()
+    error = exc_info.value
+    assert "closed" in error.message
+
+
+def test_should_reject_response_finished_if_context_closes(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+
+    def handle_get(request: http.Request) -> None:
+        # In Firefox, |fetch| will be hanging until it receives |Content-Type| header
+        # from server.
+        request.setHeader("Content-Type", "text/plain; charset=utf-8")
+        request.write(b"hello ")
+
+    server.set_route("/get", handle_get)
+    # send request and wait for server response
+    with page.expect_response("**/*") as response_info:
+        page.evaluate("() => fetch('./get', { method: 'GET' })")
+    page_response = response_info.value
+
+    page.context.close()
+    with pytest.raises(Error) as exc_info:
+        page_response.finished()
+    error = exc_info.value
+    assert "closed" in error.message
+
+
+def test_should_return_http_version(page: Page, server: Server) -> None:
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.http_version() in ("HTTP/1.0", "HTTP/1.1", "HTTP/2.0")
diff --git a/tests/sync/test_page_request_fallback.py b/tests/sync/test_page_request_fallback.py
new file mode 100644
index 000000000..53570960c
--- /dev/null
+++ b/tests/sync/test_page_request_fallback.py
@@ -0,0 +1,349 @@
+# 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.
+
+from typing import Any, Callable, List
+
+import pytest
+
+from playwright.sync_api import Error, Page, Request, Route
+from tests.server import Server
+
+
+def _append_with_return_value(values: List, value: Any) -> Any:
+    values.append(value)
+
+
+def test_should_work(page: Page, server: Server) -> None:
+    page.route("**/*", lambda route: route.fallback())
+    page.goto(server.EMPTY_PAGE)
+
+
+def test_should_fall_back(page: Page, server: Server) -> None:
+    intercepted: List[str] = []
+    page.route(
+        "**/empty.html",
+        lambda route: (
+            _append_with_return_value(intercepted, 1),
+            route.fallback(),
+        ),
+    )
+    page.route(
+        "**/empty.html",
+        lambda route: (
+            _append_with_return_value(intercepted, 2),
+            route.fallback(),
+        ),
+    )
+    page.route(
+        "**/empty.html",
+        lambda route: (
+            _append_with_return_value(intercepted, 3),
+            route.fallback(),
+        ),
+    )
+
+    page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+def test_should_fall_back_async_delayed(page: Page, server: Server) -> None:
+    intercepted: List[str] = []
+
+    def create_handler(i: int) -> Callable[[Route], None]:
+        def handler(route: Route) -> None:
+            _append_with_return_value(intercepted, i)
+            page.wait_for_timeout(500)
+            route.fallback()
+
+        return handler
+
+    page.route("**/empty.html", create_handler(1))
+    page.route("**/empty.html", create_handler(2))
+    page.route("**/empty.html", create_handler(3))
+    page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+def test_should_chain_once(page: Page, server: Server) -> None:
+    page.route(
+        "**/madeup.txt",
+        lambda route: route.fulfill(status=200, body="fulfilled one"),
+        times=1,
+    )
+    page.route("**/madeup.txt", lambda route: route.fallback(), times=1)
+
+    resp = page.goto(server.PREFIX + "/madeup.txt")
+    assert resp
+    body = resp.body()
+    assert body == b"fulfilled one"
+
+
+def test_should_not_chain_fulfill(page: Page, server: Server) -> None:
+    failed: List[bool] = [False]
+
+    def handler(route: Route) -> None:
+        failed[0] = True
+
+    page.route("**/empty.html", handler)
+    page.route(
+        "**/empty.html",
+        lambda route: route.fulfill(status=200, body="fulfilled"),
+    )
+    page.route("**/empty.html", lambda route: route.fallback())
+
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    body = response.body()
+    assert body == b"fulfilled"
+    assert not failed[0]
+
+
+def test_should_not_chain_abort(
+    page: Page, server: Server, is_webkit: bool, is_firefox: bool
+) -> None:
+    failed: List[bool] = [False]
+
+    def handler(route: Route) -> None:
+        failed[0] = True
+
+    page.route("**/empty.html", handler)
+    page.route("**/empty.html", lambda route: route.abort())
+    page.route("**/empty.html", lambda route: route.fallback())
+
+    with pytest.raises(Error) as excinfo:
+        page.goto(server.EMPTY_PAGE)
+    if is_webkit:
+        assert "Blocked by Web Inspector" in excinfo.value.message
+    elif is_firefox:
+        assert "NS_ERROR_FAILURE" in excinfo.value.message
+    else:
+        assert "net::ERR_FAILED" in excinfo.value.message
+    assert not failed[0]
+
+
+def test_should_fall_back_after_exception(page: Page, server: Server) -> None:
+    page.route("**/empty.html", lambda route: route.continue_())
+
+    def handler(route: Route) -> None:
+        try:
+            route.fulfill(response=47)  # type: ignore
+        except Exception:
+            route.fallback()
+
+    page.route("**/empty.html", handler)
+
+    page.goto(server.EMPTY_PAGE)
+
+
+def test_should_amend_http_headers(page: Page, server: Server) -> None:
+    values: List[str] = []
+
+    def handler(route: Route) -> None:
+        _append_with_return_value(values, route.request.headers.get("foo"))
+        _append_with_return_value(values, route.request.header_value("FOO"))
+        route.continue_()
+
+    page.route("**/sleep.zzz", handler)
+
+    def handler_with_header_mods(route: Route) -> None:
+        route.fallback(headers={**route.request.headers, "FOO": "bar"})
+
+    page.route("**/*", handler_with_header_mods)
+
+    page.goto(server.EMPTY_PAGE)
+    with server.expect_request("/sleep.zzz") as server_request_info:
+        page.evaluate("() => fetch('/sleep.zzz')")
+    _append_with_return_value(values, server_request_info.value.getHeader("foo"))
+    assert values == ["bar", "bar", "bar"]
+
+
+def test_should_delete_header_with_undefined_value(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    server.set_route(
+        "/something",
+        lambda r: (
+            r.setHeader("Acces-Control-Allow-Origin", "*"),
+            r.write(b"done"),
+            r.finish(),
+        ),
+    )
+
+    intercepted_request = []
+
+    def capture_and_continue(route: Route, request: Request) -> None:
+        intercepted_request.append(request)
+        route.continue_()
+
+    page.route("**/*", capture_and_continue)
+
+    def delete_foo_header(route: Route, request: Request) -> None:
+        headers = request.all_headers()
+        route.fallback(headers={**headers, "foo": None})  # type: ignore
+
+    page.route(server.PREFIX + "/something", delete_foo_header)
+    with server.expect_request("/something") as server_req_info:
+        text = page.evaluate(
+            """
+            async url => {
+                const data = await fetch(url, {
+                    headers: {
+                    foo: 'a',
+                    bar: 'b',
+                    }
+                });
+                return data.text();
+                }
+            """,
+            server.PREFIX + "/something",
+        )
+    server_req = server_req_info.value
+    assert text == "done"
+    assert not intercepted_request[0].headers.get("foo")
+    assert intercepted_request[0].headers.get("bar") == "b"
+    assert not server_req.getHeader("foo")
+    assert server_req.getHeader("bar") == "b"
+
+
+def test_should_amend_method(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    method: List[str] = []
+    page.route(
+        "**/*",
+        lambda route: (
+            _append_with_return_value(method, route.request.method),
+            route.continue_(),
+        ),
+    )
+    page.route("**/*", lambda route: route.fallback(method="POST"))
+
+    with server.expect_request("/sleep.zzz") as request_info:
+        page.evaluate("() => fetch('/sleep.zzz')")
+    request = request_info.value
+    assert method == ["POST"]
+    assert request.method == b"POST"
+
+
+def test_should_override_request_url(page: Page, server: Server) -> None:
+    url: List[str] = []
+    page.route(
+        "**/global-var.html",
+        lambda route: (
+            _append_with_return_value(url, route.request.url),
+            route.continue_(),
+        ),
+    )
+    page.route(
+        "**/foo",
+        lambda route: route.fallback(url=server.PREFIX + "/global-var.html"),
+    )
+
+    with server.expect_request("/global-var.html") as server_request_info:
+        with page.expect_event("response") as response_info:
+            page.goto(server.PREFIX + "/foo")
+    server_request = server_request_info.value
+    response = response_info.value
+    assert url == [server.PREFIX + "/global-var.html"]
+    assert response.url == server.PREFIX + "/global-var.html"
+    assert response.request.url == server.PREFIX + "/global-var.html"
+    assert page.evaluate("() => window['globalVar']") == 123
+    assert server_request.uri == b"/global-var.html"
+    assert server_request.method == b"GET"
+
+
+def test_should_amend_post_data(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    post_data: List[str] = []
+    page.route(
+        "**/*",
+        lambda route: (
+            _append_with_return_value(post_data, route.request.post_data),
+            route.continue_(),
+        ),
+    )
+    page.route("**/*", lambda route: route.fallback(post_data="doggo"))
+
+    with server.expect_request("/sleep.zzz") as server_request_info:
+        page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })")
+    server_request = server_request_info.value
+    assert post_data == ["doggo"]
+    assert server_request.post_body == b"doggo"
+
+
+def test_should_amend_binary_post_data(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    post_data_buffer: List[str] = []
+    page.route(
+        "**/*",
+        lambda route: (
+            _append_with_return_value(post_data_buffer, route.request.post_data),
+            route.continue_(),
+        ),
+    )
+    page.route("**/*", lambda route: route.fallback(post_data=b"\x00\x01\x02\x03\x04"))
+
+    with server.expect_request("/sleep.zzz") as server_request_info:
+        page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })")
+    server_request = server_request_info.value
+    # FIXME: should this be bytes?
+    assert post_data_buffer == ["\x00\x01\x02\x03\x04"]
+    assert server_request.method == b"POST"
+    assert server_request.post_body == b"\x00\x01\x02\x03\x04"
+
+
+def test_should_chain_fallback_with_dynamic_url(server: Server, page: Page) -> None:
+    intercepted: List[int] = []
+    page.route(
+        "**/bar",
+        lambda route: (
+            _append_with_return_value(intercepted, 1),
+            route.fallback(url=server.EMPTY_PAGE),
+        ),
+    )
+    page.route(
+        "**/foo",
+        lambda route: (
+            _append_with_return_value(intercepted, 2),
+            route.fallback(url="http://localhost/bar"),
+        ),
+    )
+    page.route(
+        "**/empty.html",
+        lambda route: (
+            _append_with_return_value(intercepted, 3),
+            route.fallback(url="http://localhost/foo"),
+        ),
+    )
+
+    page.goto(server.EMPTY_PAGE)
+    assert intercepted == [3, 2, 1]
+
+
+def test_should_amend_json_post_data(server: Server, page: Page) -> None:
+    page.goto(server.EMPTY_PAGE)
+    post_data = []
+
+    def handler(route: Route) -> None:
+        post_data.append(route.request.post_data)
+        route.continue_()
+
+    page.route("**/*", handler)
+    page.route(
+        "**/*",
+        lambda route: route.fallback(post_data={"foo": "bar"}),
+    )
+
+    with server.expect_request("/sleep.zzz") as server_request:
+        page.evaluate("() => fetch('/sleep.zzz', { method: 'POST', body: 'birdy' })")
+    assert post_data == ['{"foo": "bar"}']
+    assert server_request.value.post_body == b'{"foo": "bar"}'
diff --git a/tests/sync/test_page_request_gc.py b/tests/sync/test_page_request_gc.py
new file mode 100644
index 000000000..bfddc2320
--- /dev/null
+++ b/tests/sync/test_page_request_gc.py
@@ -0,0 +1,34 @@
+# 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.
+
+from playwright.sync_api import Page
+from tests.server import Server
+
+
+def test_should_work(page: Page, server: Server) -> None:
+    page.evaluate(
+        """() => {
+        globalThis.objectToDestroy = { hello: 'world' };
+        globalThis.weakRef = new WeakRef(globalThis.objectToDestroy);
+    }"""
+    )
+    page.request_gc()
+    assert page.evaluate("() => globalThis.weakRef.deref()") == {"hello": "world"}
+
+    page.request_gc()
+    assert page.evaluate("() => globalThis.weakRef.deref()") == {"hello": "world"}
+
+    page.evaluate("() => globalThis.objectToDestroy = null")
+    page.request_gc()
+    assert page.evaluate("() => globalThis.weakRef.deref()") is None
diff --git a/tests/sync/test_page_request_intercept.py b/tests/sync/test_page_request_intercept.py
new file mode 100644
index 000000000..1d3dd0f46
--- /dev/null
+++ b/tests/sync/test_page_request_intercept.py
@@ -0,0 +1,54 @@
+# 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 pytest
+
+from playwright.sync_api import Error, Page, Route
+from tests.server import Server, TestServerRequest
+
+
+def test_should_support_timeout_option_in_route_fetch(
+    server: Server, page: Page
+) -> None:
+    def _handle(request: TestServerRequest) -> None:
+        request.responseHeaders.addRawHeader("Content-Length", "4096")
+        request.responseHeaders.addRawHeader("Content-Type", "text/html")
+        request.write(b"")
+
+    server.set_route(
+        "/slow",
+        _handle,
+    )
+
+    def handle(route: Route) -> None:
+        with pytest.raises(Error) as error:
+            route.fetch(timeout=1000)
+        assert "Route.fetch: Timeout 1000ms exceeded." in error.value.message
+
+    page.route("**/*", lambda route: handle(route))
+    with pytest.raises(Error) as error:
+        page.goto(server.PREFIX + "/slow", timeout=2000)
+    assert "Timeout 2000ms exceeded" in error.value.message
+
+
+def test_should_intercept_with_url_override(server: Server, page: Page) -> None:
+    def handle(route: Route) -> None:
+        response = route.fetch(url=server.PREFIX + "/one-style.html")
+        route.fulfill(response=response)
+
+    page.route("**/*.html", lambda route: handle(route))
+    response = page.goto(server.PREFIX + "/empty.html")
+    assert response
+    assert response.status == 200
+    assert "one-style.css" in response.body().decode("utf-8")
diff --git a/tests/sync/test_page_request_timeout.py b/tests/sync/test_page_request_timeout.py
new file mode 100644
index 000000000..8b65da26d
--- /dev/null
+++ b/tests/sync/test_page_request_timeout.py
@@ -0,0 +1,36 @@
+# 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 pytest
+
+from playwright.sync_api import BrowserContext, Error, Page
+from tests.server import Server
+
+
+def test_context_request_should_support_timeout_option(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    # https://github.com/microsoft/playwright/issues/39220
+
+    server.set_route("/", lambda req: None)
+    with pytest.raises(Error, match="Timeout 123ms exceeded"):
+        page.request.get(server.PREFIX, timeout=123)
+    with pytest.raises(Error, match="Timeout 123ms exceeded"):
+        context.request.get(server.PREFIX, timeout=123)
+
+    context.set_default_timeout(123)
+    with pytest.raises(Error, match="Timeout 123ms exceeded"):
+        page.request.get(server.PREFIX)
+    with pytest.raises(Error, match="Timeout 123ms exceeded"):
+        context.request.get(server.PREFIX)
diff --git a/tests/sync/test_page_select_option.py b/tests/sync/test_page_select_option.py
new file mode 100644
index 000000000..7bb6ade85
--- /dev/null
+++ b/tests/sync/test_page_select_option.py
@@ -0,0 +1,255 @@
+# 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 pytest
+
+from playwright.sync_api import Error, Page
+from tests.server import Server
+
+
+def test_select_option_should_select_single_option(server: Server, page: Page) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.select_option("select", "blue")
+    assert page.evaluate("result.onInput") == ["blue"]
+    assert page.evaluate("result.onChange") == ["blue"]
+
+
+def test_select_option_should_select_single_option_by_value(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.select_option("select", "blue")
+    assert page.evaluate("result.onInput") == ["blue"]
+    assert page.evaluate("result.onChange") == ["blue"]
+
+
+def test_select_option_should_select_single_option_by_label(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.select_option("select", label="Indigo")
+    assert page.evaluate("result.onInput") == ["indigo"]
+    assert page.evaluate("result.onChange") == ["indigo"]
+
+
+def test_select_option_should_select_single_option_by_empty_label(
+    page: Page, server: Server
+) -> None:
+    page.set_content(
+        """
+        <select>
+            <option value="indigo">Indigo</option>
+            <option value="violet"></option>
+        </select>
+    """
+    )
+    assert page.locator("select").input_value() == "indigo"
+    page.select_option("select", label="")
+    assert page.locator("select").input_value() == "violet"
+
+
+def test_select_option_should_select_single_option_by_handle(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.select_option("select", element=page.query_selector("[id=whiteOption]"))
+    assert page.evaluate("result.onInput") == ["white"]
+    assert page.evaluate("result.onChange") == ["white"]
+
+
+def test_select_option_should_select_single_option_by_index(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.select_option("select", index=2)
+    assert page.evaluate("result.onInput") == ["brown"]
+    assert page.evaluate("result.onChange") == ["brown"]
+
+
+def test_select_option_should_select_single_option_by_index_0(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.select_option("select", index=0)
+    assert page.evaluate("result.onInput") == ["black"]
+
+
+def test_select_option_should_select_only_first_option(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.select_option("select", ["blue", "green", "red"])
+    assert page.evaluate("result.onInput") == ["blue"]
+    assert page.evaluate("result.onChange") == ["blue"]
+
+
+def test_select_option_should_not_throw_when_select_causes_navigation(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.eval_on_selector(
+        "select",
+        "select => select.addEventListener('input', () => window.location = '/empty.html')",
+    )
+    with page.expect_navigation():
+        page.select_option("select", "blue")
+    assert "empty.html" in page.url
+
+
+def test_select_option_should_select_multiple_options(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.evaluate("makeMultiple()")
+    page.select_option("select", ["blue", "green", "red"])
+    assert page.evaluate("result.onInput") == ["blue", "green", "red"]
+    assert page.evaluate("result.onChange") == ["blue", "green", "red"]
+
+
+def test_select_option_should_select_multiple_options_with_attributes(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.evaluate("makeMultiple()")
+    page.select_option(
+        "select",
+        value="blue",
+        label="Green",
+        index=4,
+    )
+    assert page.evaluate("result.onInput") == ["blue", "gray", "green"]
+    assert page.evaluate("result.onChange") == ["blue", "gray", "green"]
+
+
+def test_select_option_should_select_option_with_empty_value(
+    page: Page, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.set_content(
+        """
+        <select>
+            <option value="first">First</option>
+            <option value="">Second</option>
+        </select>
+    """
+    )
+    assert page.locator("select").input_value() == "first"
+    page.select_option("select", value="")
+    assert page.locator("select").input_value() == ""
+
+
+def test_select_option_should_respect_event_bubbling(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.select_option("select", "blue")
+    assert page.evaluate("result.onBubblingInput") == ["blue"]
+    assert page.evaluate("result.onBubblingChange") == ["blue"]
+
+
+def test_select_option_should_throw_when_element_is_not_a__select_(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    with pytest.raises(Error) as exc_info:
+        page.select_option("body", "")
+    assert "Element is not a <select> element" in exc_info.value.message
+
+
+def test_select_option_should_return_on_no_matched_values(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    with pytest.raises(Error) as exc_info:
+        page.select_option("select", ["42", "abc"], timeout=1000)
+    assert "Timeout 1000" in exc_info.value.message
+
+
+def test_select_option_should_return_an_array_of_matched_values(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.evaluate("makeMultiple()")
+    result = page.select_option("select", ["blue", "black", "magenta"])
+    assert result == ["black", "blue", "magenta"]
+
+
+def test_select_option_should_return_an_array_of_one_element_when_multiple_is_not_set(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    result = page.select_option("select", ["42", "blue", "black", "magenta"])
+    assert len(result) == 1
+
+
+def test_select_option_should_return_on_no_values(server: Server, page: Page) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    result = page.select_option("select", [])
+    assert result == []
+
+
+def test_select_option_should_unselect_with_null(server: Server, page: Page) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.evaluate("makeMultiple()")
+    result = page.select_option("select", ["blue", "black", "magenta"])
+    assert result == ["black", "blue", "magenta"]
+    page.select_option("select", None)
+    assert page.eval_on_selector(
+        "select",
+        "select => Array.from(select.options).every(option => !option.selected)",
+    )
+
+
+def test_select_option_should_deselect_all_options_when_passed_no_values_for_a_multiple_select(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.evaluate("makeMultiple()")
+    page.select_option("select", ["blue", "black", "magenta"])
+    page.select_option("select", [])
+    assert page.eval_on_selector(
+        "select",
+        "select => Array.from(select.options).every(option => !option.selected)",
+    )
+
+
+def test_select_option_should_deselect_all_options_when_passed_no_values_for_a_select_without_multiple(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.select_option("select", ["blue", "black", "magenta"])
+    page.select_option("select", [])
+    assert page.eval_on_selector(
+        "select",
+        "select => Array.from(select.options).every(option => !option.selected)",
+    )
+
+
+def test_select_option_should_work_when_re_defining_top_level_event_class(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.evaluate("window.Event = null")
+    page.select_option("select", "blue")
+    assert page.evaluate("result.onInput") == ["blue"]
+    assert page.evaluate("result.onChange") == ["blue"]
+
+
+def test_select_options_should_fall_back_to_selecting_by_label(
+    server: Server, page: Page
+) -> None:
+    page.goto(server.PREFIX + "/input/select.html")
+    page.select_option("select", "Blue")
+    assert page.evaluate("result.onInput") == ["blue"]
+    assert page.evaluate("result.onChange") == ["blue"]
diff --git a/tests/sync/test_pdf.py b/tests/sync/test_pdf.py
index b93de201d..552d0f6bf 100644
--- a/tests/sync/test_pdf.py
+++ b/tests/sync/test_pdf.py
@@ -17,17 +17,17 @@
 
 import pytest
 
-from playwright._impl._page import Page
+from playwright.sync_api import Page
 
 
 @pytest.mark.only_browser("chromium")
-def test_should_be_able_to_save_pdf_file(page: Page, server, tmpdir: Path):
-    output_file = tmpdir / "foo.png"
+def test_should_be_able_to_save_pdf_file(page: Page, tmp_path: Path) -> None:
+    output_file = tmp_path / "foo.png"
     page.pdf(path=str(output_file))
     assert os.path.getsize(output_file) > 0
 
 
 @pytest.mark.only_browser("chromium")
-def test_should_be_able_capture_pdf_without_path(page: Page):
+def test_should_be_able_capture_pdf_without_path(page: Page) -> None:
     buffer = page.pdf()
     assert buffer
diff --git a/tests/sync/test_queryselector.py b/tests/sync/test_queryselector.py
new file mode 100644
index 000000000..27b972e95
--- /dev/null
+++ b/tests/sync/test_queryselector.py
@@ -0,0 +1,378 @@
+# 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.
+from pathlib import Path
+
+import pytest
+
+from playwright.sync_api import Browser, Error, Page, Selectors
+
+from .utils import Utils
+
+
+def test_selectors_register_should_work(
+    selectors: Selectors, browser: Browser, browser_name: str
+) -> None:
+    tag_selector = """
+        {
+            create(root, target) {
+                return target.nodeName;
+            },
+            query(root, selector) {
+                return root.querySelector(selector);
+            },
+            queryAll(root, selector) {
+                return Array.from(root.querySelectorAll(selector));
+            }
+        }"""
+
+    selector_name = f"tag_{browser_name}"
+    selector2_name = f"tag2_{browser_name}"
+
+    # Register one engine before creating context.
+    selectors.register(selector_name, tag_selector)
+
+    context = browser.new_context()
+    # Register another engine after creating context.
+    selectors.register(selector2_name, tag_selector)
+
+    page = context.new_page()
+    page.set_content("<div><span></span></div><div></div>")
+
+    assert page.eval_on_selector(f"{selector_name}=DIV", "e => e.nodeName") == "DIV"
+    assert page.eval_on_selector(f"{selector_name}=SPAN", "e => e.nodeName") == "SPAN"
+    assert page.eval_on_selector_all(f"{selector_name}=DIV", "es => es.length") == 2
+
+    assert page.eval_on_selector(f"{selector2_name}=DIV", "e => e.nodeName") == "DIV"
+    assert page.eval_on_selector(f"{selector2_name}=SPAN", "e => e.nodeName") == "SPAN"
+    assert page.eval_on_selector_all(f"{selector2_name}=DIV", "es => es.length") == 2
+
+    # Selector names are case-sensitive.
+    with pytest.raises(Error) as exc:
+        page.query_selector("tAG=DIV")
+    assert 'Unknown engine "tAG" while parsing selector tAG=DIV' in exc.value.message
+
+    context.close()
+
+
+def test_selectors_register_should_work_with_path(
+    selectors: Selectors, page: Page, utils: Utils, assetdir: Path
+) -> None:
+    utils.register_selector_engine(
+        selectors, "foo", path=assetdir / "sectionselectorengine.js"
+    )
+    page.set_content("<section></section>")
+    assert page.eval_on_selector("foo=whatever", "e => e.nodeName") == "SECTION"
+
+
+def test_selectors_register_should_work_in_main_and_isolated_world(
+    selectors: Selectors, page: Page, utils: Utils
+) -> None:
+    dummy_selector_script = """{
+      create(root, target) { },
+      query(root, selector) {
+        return window.__answer;
+      },
+      queryAll(root, selector) {
+        return window['__answer'] ? [window['__answer'], document.body, document.documentElement] : [];
+      }
+    }"""
+
+    utils.register_selector_engine(selectors, "main", dummy_selector_script)
+    utils.register_selector_engine(
+        selectors, "isolated", dummy_selector_script, content_script=True
+    )
+    page.set_content("<div><span><section></section></span></div>")
+    page.evaluate('() => window.__answer = document.querySelector("span")')
+    # Works in main if asked.
+    assert page.eval_on_selector("main=ignored", "e => e.nodeName") == "SPAN"
+    assert page.eval_on_selector("css=div >> main=ignored", "e => e.nodeName") == "SPAN"
+    assert page.eval_on_selector_all(
+        "main=ignored", "es => window.__answer !== undefined"
+    )
+    assert (
+        page.eval_on_selector_all("main=ignored", "es => es.filter(e => e).length") == 3
+    )
+    # Works in isolated by default.
+    assert page.query_selector("isolated=ignored") is None
+    assert page.query_selector("css=div >> isolated=ignored") is None
+    # $$eval always works in main, to avoid adopting nodes one by one.
+    assert page.eval_on_selector_all(
+        "isolated=ignored", "es => window.__answer !== undefined"
+    )
+    assert (
+        page.eval_on_selector_all("isolated=ignored", "es => es.filter(e => e).length")
+        == 3
+    )
+    # At least one engine in main forces all to be in main.
+    assert (
+        page.eval_on_selector("main=ignored >> isolated=ignored", "e => e.nodeName")
+        == "SPAN"
+    )
+    assert (
+        page.eval_on_selector("isolated=ignored >> main=ignored", "e => e.nodeName")
+        == "SPAN"
+    )
+    # Can be chained to css.
+    assert (
+        page.eval_on_selector("main=ignored >> css=section", "e => e.nodeName")
+        == "SECTION"
+    )
+
+
+def test_selectors_register_should_handle_errors(
+    selectors: Selectors, page: Page, utils: Utils
+) -> None:
+    with pytest.raises(Error) as exc:
+        page.query_selector("neverregister=ignored")
+    assert (
+        'Unknown engine "neverregister" while parsing selector neverregister=ignored'
+        in exc.value.message
+    )
+
+    dummy_selector_engine_script = """{
+      create(root, target) {
+        return target.nodeName;
+      },
+      query(root, selector) {
+        return root.querySelector('dummy');
+      },
+      queryAll(root, selector) {
+        return Array.from(root.query_selector_all('dummy'));
+      }
+    }"""
+
+    with pytest.raises(Error) as exc:
+        selectors.register("$", dummy_selector_engine_script)
+    assert (
+        exc.value.message
+        == "Selectors.register: Selector engine name may only contain [a-zA-Z0-9_] characters"
+    )
+
+    # Selector names are case-sensitive.
+    utils.register_selector_engine(selectors, "dummy", dummy_selector_engine_script)
+    utils.register_selector_engine(selectors, "duMMy", dummy_selector_engine_script)
+
+    with pytest.raises(Error) as exc:
+        selectors.register("dummy", dummy_selector_engine_script)
+    assert (
+        exc.value.message
+        == 'Selectors.register: "dummy" selector engine has been already registered'
+    )
+
+    with pytest.raises(Error) as exc:
+        selectors.register("css", dummy_selector_engine_script)
+    assert (
+        exc.value.message == 'Selectors.register: "css" is a predefined selector engine'
+    )
+
+
+def test_should_work_with_layout_selectors(page: Page) -> None:
+    #        +--+  +--+
+    #        | 1|  | 2|
+    #        +--+  ++-++
+    #        | 3|   | 4|
+    #   +-------+  ++-++
+    #   |   0   |  | 5|
+    #   | +--+  +--+--+
+    #   | | 6|  | 7|
+    #   | +--+  +--+
+    #   |       |
+    #   O-------+
+    #           +--+
+    #           | 8|
+    #           +--++--+
+    #               | 9|
+    #               +--+
+
+    boxes = [
+        # x, y, width, height
+        [0, 0, 150, 150],
+        [100, 200, 50, 50],
+        [200, 200, 50, 50],
+        [100, 150, 50, 50],
+        [201, 150, 50, 50],
+        [200, 100, 50, 50],
+        [50, 50, 50, 50],
+        [150, 50, 50, 50],
+        [150, -51, 50, 50],
+        [201, -101, 50, 50],
+    ]
+    page.set_content(
+        '<container style="width: 500px; height: 500px; position: relative;"></container>'
+    )
+    page.eval_on_selector(
+        "container",
+        """(container, boxes) => {
+    for (let i = 0; i < boxes.length; i++) {
+      const div = document.createElement('div');
+      div.style.position = 'absolute';
+      div.style.overflow = 'hidden';
+      div.style.boxSizing = 'border-box';
+      div.style.border = '1px solid black';
+      div.id = 'id' + i;
+      div.textContent = 'id' + i;
+      const box = boxes[i];
+      div.style.left = box[0] + 'px';
+      // Note that top is a flipped y coordinate.
+      div.style.top = (250 - box[1] - box[3]) + 'px';
+      div.style.width = box[2] + 'px';
+      div.style.height = box[3] + 'px';
+      container.appendChild(div);
+      const span = document.createElement('span');
+      span.textContent = '' + i;
+      div.appendChild(span);
+    }
+  }""",
+        boxes,
+    )
+
+    assert page.eval_on_selector("div:right-of(#id6)", "e => e.id") == "id7"
+    assert page.eval_on_selector("div:right-of(#id1)", "e => e.id") == "id2"
+    assert page.eval_on_selector("div:right-of(#id3)", "e => e.id") == "id4"
+    assert page.query_selector("div:right-of(#id4)") is None
+    assert page.eval_on_selector("div:right-of(#id0)", "e => e.id") == "id7"
+    assert page.eval_on_selector("div:right-of(#id8)", "e => e.id") == "id9"
+    assert (
+        page.eval_on_selector_all(
+            "div:right-of(#id3)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id4,id2,id5,id7,id8,id9"
+    )
+    assert (
+        page.eval_on_selector_all(
+            "div:right-of(#id3, 50)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id2,id5,id7,id8"
+    )
+    assert (
+        page.eval_on_selector_all(
+            "div:right-of(#id3, 49)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id7,id8"
+    )
+
+    assert page.eval_on_selector("div:left-of(#id2)", "e => e.id") == "id1"
+    assert page.query_selector("div:left-of(#id0)") is None
+    assert page.eval_on_selector("div:left-of(#id5)", "e => e.id") == "id0"
+    assert page.eval_on_selector("div:left-of(#id9)", "e => e.id") == "id8"
+    assert page.eval_on_selector("div:left-of(#id4)", "e => e.id") == "id3"
+    assert (
+        page.eval_on_selector_all(
+            "div:left-of(#id5)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0,id7,id3,id1,id6,id8"
+    )
+    assert (
+        page.eval_on_selector_all(
+            "div:left-of(#id5, 3)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id7,id8"
+    )
+
+    assert page.eval_on_selector("div:above(#id0)", "e => e.id") == "id3"
+    assert page.eval_on_selector("div:above(#id5)", "e => e.id") == "id4"
+    assert page.eval_on_selector("div:above(#id7)", "e => e.id") == "id5"
+    assert page.eval_on_selector("div:above(#id8)", "e => e.id") == "id0"
+    assert page.eval_on_selector("div:above(#id9)", "e => e.id") == "id8"
+    assert page.query_selector("div:above(#id2)") is None
+    assert (
+        page.eval_on_selector_all(
+            "div:above(#id5)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id4,id2,id3,id1"
+    )
+    assert (
+        page.eval_on_selector_all(
+            "div:above(#id5, 20)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id4,id3"
+    )
+
+    assert page.eval_on_selector("div:below(#id4)", "e => e.id") == "id5"
+    assert page.eval_on_selector("div:below(#id3)", "e => e.id") == "id0"
+    assert page.eval_on_selector("div:below(#id2)", "e => e.id") == "id4"
+    assert page.eval_on_selector("div:below(#id6)", "e => e.id") == "id8"
+    assert page.eval_on_selector("div:below(#id7)", "e => e.id") == "id8"
+    assert page.eval_on_selector("div:below(#id8)", "e => e.id") == "id9"
+    assert page.query_selector("div:below(#id9)") is None
+    assert (
+        page.eval_on_selector_all(
+            "div:below(#id3)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0,id5,id6,id7,id8,id9"
+    )
+    assert (
+        page.eval_on_selector_all(
+            "div:below(#id3, 105)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0,id5,id6,id7"
+    )
+
+    assert page.eval_on_selector("div:near(#id0)", "e => e.id") == "id3"
+    assert (
+        page.eval_on_selector_all(
+            "div:near(#id7)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0,id5,id3,id6"
+    )
+    assert (
+        page.eval_on_selector_all(
+            "div:near(#id0)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id3,id6,id7,id8,id1,id5"
+    )
+    assert (
+        page.eval_on_selector_all(
+            "div:near(#id6)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0,id3,id7"
+    )
+    assert (
+        page.eval_on_selector_all(
+            "div:near(#id6, 10)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id0"
+    )
+    assert (
+        page.eval_on_selector_all(
+            "div:near(#id0, 100)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id3,id6,id7,id8,id1,id5,id4,id2"
+    )
+
+    assert (
+        page.eval_on_selector_all(
+            "div:below(#id5):above(#id8)", "els => els.map(e => e.id).join(',')"
+        )
+        == "id7,id6"
+    )
+    assert page.eval_on_selector("div:below(#id5):above(#id8)", "e => e.id") == "id7"
+
+    assert (
+        page.eval_on_selector_all(
+            "div:right-of(#id0) + div:above(#id8)",
+            "els => els.map(e => e.id).join(',')",
+        )
+        == "id5,id6,id3"
+    )
+
+    with pytest.raises(Error) as exc_info:
+        page.query_selector(":near(50)")
+    assert (
+        '"near" engine expects a selector list and optional maximum distance in pixels'
+        in exc_info.value.message
+    )
+    with pytest.raises(Error) as exc_info:
+        page.query_selector('left-of="div"')
+    assert '"left-of" selector cannot be first' in exc_info.value.message
diff --git a/tests/sync/test_request_fulfill.py b/tests/sync/test_request_fulfill.py
new file mode 100644
index 000000000..569cf5e2c
--- /dev/null
+++ b/tests/sync/test_request_fulfill.py
@@ -0,0 +1,73 @@
+# 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.
+
+from playwright.sync_api import Page, Route
+from tests.server import Server
+
+
+def test_should_fetch_original_request_and_fulfill(page: Page, server: Server) -> None:
+    def handle(route: Route) -> None:
+        response = page.request.fetch(route.request)
+        route.fulfill(response=response)
+
+    page.route("**/*", handle)
+    response = page.goto(server.PREFIX + "/title.html")
+    assert response
+    assert response.status == 200
+    assert page.title() == "Woof-Woof"
+
+
+def test_should_fulfill_json(page: Page, server: Server) -> None:
+    def handle(route: Route) -> None:
+        route.fulfill(status=201, headers={"foo": "bar"}, json={"bar": "baz"})
+
+    page.route("**/*", handle)
+
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 201
+    assert response.headers["content-type"] == "application/json"
+    assert response.json() == {"bar": "baz"}
+
+
+def test_should_fulfill_json_overriding_existing_response(
+    page: Page, server: Server
+) -> None:
+    server.set_route(
+        "/tags",
+        lambda request: (
+            request.setHeader("foo", "bar"),
+            request.write('{"tags": ["a", "b"]}'.encode()),
+            request.finish(),
+        ),
+    )
+
+    original = {}
+
+    def handle(route: Route) -> None:
+        response = route.fetch()
+        json = response.json()
+        original["tags"] = json["tags"]
+        json["tags"] = ["c"]
+        route.fulfill(response=response, json=json)
+
+    page.route("**/*", handle)
+
+    response = page.goto(server.PREFIX + "/tags")
+    assert response
+    assert response.status == 200
+    assert response.headers["content-type"] == "application/json"
+    assert response.headers["foo"] == "bar"
+    assert original["tags"] == ["a", "b"]
+    assert response.json() == {"tags": ["c"]}
diff --git a/tests/sync/test_request_intercept.py b/tests/sync/test_request_intercept.py
new file mode 100644
index 000000000..a54c0ad71
--- /dev/null
+++ b/tests/sync/test_request_intercept.py
@@ -0,0 +1,147 @@
+# 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.
+
+from pathlib import Path
+
+from twisted.web import http
+
+from playwright.sync_api import Page, Route
+from tests.server import Server
+
+
+def test_should_not_follow_redirects_when_max_redirects_is_set_to_0_in_route_fetch(
+    server: Server, page: Page
+) -> None:
+    server.set_redirect("/foo", "/empty.html")
+
+    def handle(route: Route) -> None:
+        response = route.fetch(max_redirects=0)
+        assert response.headers["location"] == "/empty.html"
+        assert response.status == 302
+        route.fulfill(body="hello")
+
+    page.route("**/*", lambda route: handle(route))
+    page.goto(server.PREFIX + "/foo")
+    assert "hello" in page.content()
+
+
+def test_should_fulfill_intercepted_response(page: Page, server: Server) -> None:
+    def handle(route: Route) -> None:
+        response = page.request.fetch(route.request)
+        route.fulfill(
+            response=response,
+            status=201,
+            headers={"foo": "bar"},
+            content_type="text/plain",
+            body="Yo, page!",
+        )
+
+    page.route("**/*", handle)
+    response = page.goto(server.PREFIX + "/empty.html")
+    assert response
+    assert response.status == 201
+    assert response.headers["foo"] == "bar"
+    assert response.headers["content-type"] == "text/plain"
+    assert page.evaluate("() => document.body.textContent") == "Yo, page!"
+
+
+def test_should_fulfill_response_with_empty_body(page: Page, server: Server) -> None:
+    def handle(route: Route) -> None:
+        response = page.request.fetch(route.request)
+        route.fulfill(
+            response=response, status=201, body="", headers={"content-length": "0"}
+        )
+
+    page.route("**/*", handle)
+    response = page.goto(server.PREFIX + "/title.html")
+    assert response
+    assert response.status == 201
+    assert response.text() == ""
+
+
+def test_should_override_with_defaults_when_intercepted_response_not_provided(
+    page: Page, server: Server, browser_name: str
+) -> None:
+    def server_handler(request: http.Request) -> None:
+        request.setHeader("foo", "bar")
+        request.write("my content".encode())
+        request.finish()
+
+    server.set_route("/empty.html", server_handler)
+
+    def handle(route: Route) -> None:
+        page.request.fetch(route.request)
+        route.fulfill(status=201)
+
+    page.route("**/*", handle)
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 201
+    assert response.text() == ""
+    if browser_name == "webkit":
+        assert response.headers == {"content-type": "text/plain"}
+    else:
+        assert response.headers == {}
+
+
+def test_should_fulfill_with_any_response(page: Page, server: Server) -> None:
+    def server_handler(request: http.Request) -> None:
+        request.setHeader("foo", "bar")
+        request.write("Woo-hoo".encode())
+        request.finish()
+
+    server.set_route("/sample", server_handler)
+    sample_response = page.request.get(server.PREFIX + "/sample")
+    page.route(
+        "**/*",
+        lambda route: route.fulfill(
+            response=sample_response, status=201, content_type="text/plain"
+        ),
+    )
+    response = page.goto(server.EMPTY_PAGE)
+    assert response
+    assert response.status == 201
+    assert response.text() == "Woo-hoo"
+    assert response.headers["foo"] == "bar"
+
+
+def test_should_support_fulfill_after_intercept(
+    page: Page, server: Server, assetdir: Path
+) -> None:
+    def handle_route(route: Route) -> None:
+        response = page.request.fetch(route.request)
+        route.fulfill(response=response)
+
+    page.route("**", handle_route)
+    with server.expect_request("/title.html") as request_info:
+        response = page.goto(server.PREFIX + "/title.html")
+    assert response
+    request = request_info.value
+    assert request.uri.decode() == "/title.html"
+    original = (assetdir / "title.html").read_text()
+    assert response.text() == original
+
+
+def test_should_intercept_by_glob(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    page.route(
+        "http://localhos**?*oo",
+        lambda route: route.fulfill(body="intercepted", status=200),
+    )
+
+    result = page.evaluate(
+        "url => fetch(url).then(r => r.text())", server.PREFIX + "/?foo"
+    )
+
+    assert result == "intercepted"
diff --git a/tests/sync/test_resource_timing.py b/tests/sync/test_resource_timing.py
index bdfacd321..1c6efab6a 100644
--- a/tests/sync/test_resource_timing.py
+++ b/tests/sync/test_resource_timing.py
@@ -14,54 +14,42 @@
 
 import pytest
 
+from playwright.sync_api import Browser, Page, ResourceTiming
+from tests.server import Server
 
-def test_should_work(page, server, is_webkit, is_mac):
-    if is_webkit and is_mac:
-        pytest.skip()
+
+def test_should_work(page: Page, server: Server) -> None:
     with page.expect_event("requestfinished") as request_info:
         page.goto(server.EMPTY_PAGE)
     request = request_info.value
     timing = request.timing
-    assert timing["domainLookupStart"] >= 0
-    assert timing["domainLookupEnd"] >= timing["domainLookupStart"]
-    assert timing["connectStart"] >= timing["domainLookupEnd"]
-    assert timing["secureConnectionStart"] == -1
-    assert timing["connectEnd"] > timing["secureConnectionStart"]
+    verify_connections_timing_consistency(timing)
     assert timing["requestStart"] >= timing["connectEnd"]
-    assert timing["responseStart"] > timing["requestStart"]
+    assert timing["responseStart"] >= timing["requestStart"]
     assert timing["responseEnd"] >= timing["responseStart"]
     assert timing["responseEnd"] < 10000
 
 
-def test_should_work_for_subresource(page, server, is_win, is_mac, is_webkit):
-    if is_webkit and is_mac:
+def test_should_work_for_subresource(
+    page: Page, server: Server, is_win: bool, is_mac: bool, is_webkit: bool
+) -> None:
+    if is_webkit and (is_mac or is_win):
         pytest.skip()
     requests = []
     page.on("requestfinished", lambda request: requests.append(request))
     page.goto(server.PREFIX + "/one-style.html")
-    assert len(requests) == 2
+    assert len(requests) >= 2
     timing = requests[1].timing
-    if is_webkit and is_win:
-        # Curl does not reuse connections.
-        assert timing["domainLookupStart"] >= 0
-        assert timing["domainLookupEnd"] >= timing["domainLookupStart"]
-        assert timing["connectStart"] >= timing["domainLookupEnd"]
-        assert timing["secureConnectionStart"] == -1
-        assert timing["connectEnd"] > timing["secureConnectionStart"]
-    else:
-        assert timing["domainLookupStart"] == 0 or timing["domainLookupStart"] == -1
-        assert timing["domainLookupEnd"] == 0 or timing["domainLookupEnd"] == -1
-        assert timing["connectStart"] == 0 or timing["connectStart"] == -1
-        assert timing["connectEnd"] == 0 or timing["connectEnd"] == -1
-        assert timing["secureConnectionStart"] == -1
-
+    verify_connections_timing_consistency(timing)
     assert timing["requestStart"] >= 0
     assert timing["responseStart"] > timing["requestStart"]
     assert timing["responseEnd"] >= timing["responseStart"]
     assert timing["responseEnd"] < 10000
 
 
-def test_should_work_for_ssl(browser, https_server, is_mac, is_webkit):
+def test_should_work_for_ssl(
+    browser: Browser, https_server: Server, is_mac: bool, is_webkit: bool
+) -> None:
     if is_webkit and is_mac:
         pytest.skip()
     page = browser.new_page(ignore_https_errors=True)
@@ -69,22 +57,16 @@ def test_should_work_for_ssl(browser, https_server, is_mac, is_webkit):
         page.goto(https_server.EMPTY_PAGE)
     request = request_info.value
     timing = request.timing
-    if not (is_webkit and is_mac):
-        assert timing["domainLookupStart"] >= 0
-        assert timing["domainLookupEnd"] >= timing["domainLookupStart"]
-        assert timing["connectStart"] >= timing["domainLookupEnd"]
-        assert timing["secureConnectionStart"] > timing["connectStart"]
-        assert timing["connectEnd"] > timing["secureConnectionStart"]
-        assert timing["requestStart"] >= timing["connectEnd"]
-
-    assert timing["responseStart"] > timing["requestStart"]
+    verify_connections_timing_consistency(timing)
+    assert timing["requestStart"] >= timing["connectEnd"]
+    assert timing["responseStart"] >= timing["requestStart"]
     assert timing["responseEnd"] >= timing["responseStart"]
     assert timing["responseEnd"] < 10000
     page.close()
 
 
 @pytest.mark.skip_browser("webkit")  # In WebKit, redirects don"t carry the timing info
-def test_should_work_for_redirect(page, server):
+def test_should_work_for_redirect(page: Page, server: Server) -> None:
     server.set_redirect("/foo.html", "/empty.html")
     responses = []
     page.on("response", lambda response: responses.append(response))
@@ -97,23 +79,27 @@ def test_should_work_for_redirect(page, server):
     assert responses[1].url == server.PREFIX + "/empty.html"
 
     timing1 = responses[0].request.timing
-    assert timing1["domainLookupStart"] >= 0
-    assert timing1["domainLookupEnd"] >= timing1["domainLookupStart"]
-    assert timing1["connectStart"] >= timing1["domainLookupEnd"]
-    assert timing1["secureConnectionStart"] == -1
-    assert timing1["connectEnd"] > timing1["secureConnectionStart"]
+    verify_connections_timing_consistency(timing1)
     assert timing1["requestStart"] >= timing1["connectEnd"]
     assert timing1["responseStart"] > timing1["requestStart"]
     assert timing1["responseEnd"] >= timing1["responseStart"]
     assert timing1["responseEnd"] < 10000
 
     timing2 = responses[1].request.timing
-    assert timing2["domainLookupStart"] == -1
-    assert timing2["domainLookupEnd"] == -1
-    assert timing2["connectStart"] == -1
-    assert timing2["secureConnectionStart"] == -1
-    assert timing2["connectEnd"] == -1
+    verify_connections_timing_consistency(timing2)
     assert timing2["requestStart"] >= 0
     assert timing2["responseStart"] > timing2["requestStart"]
     assert timing2["responseEnd"] >= timing2["responseStart"]
     assert timing2["responseEnd"] < 10000
+
+
+def verify_timing_value(value: float, previous: float) -> None:
+    assert value == -1 or value > 0 and value >= previous
+
+
+def verify_connections_timing_consistency(timing: ResourceTiming) -> None:
+    verify_timing_value(timing["domainLookupStart"], -1)
+    verify_timing_value(timing["domainLookupEnd"], timing["domainLookupStart"])
+    verify_timing_value(timing["connectStart"], timing["domainLookupEnd"])
+    verify_timing_value(timing["secureConnectionStart"], timing["connectStart"])
+    verify_timing_value(timing["connectEnd"], timing["secureConnectionStart"])
diff --git a/tests/sync/test_route_web_socket.py b/tests/sync/test_route_web_socket.py
new file mode 100644
index 000000000..6d9eb09a6
--- /dev/null
+++ b/tests/sync/test_route_web_socket.py
@@ -0,0 +1,374 @@
+# 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 re
+import time
+from typing import Any, Awaitable, Callable, Literal, Optional, Union
+
+from playwright.sync_api import Browser, Frame, Page, WebSocketRoute
+from tests.server import Server, WebSocketProtocol
+
+
+def assert_equal(
+    actual_cb: Callable[[], Union[Any, Awaitable[Any]]], expected: Any
+) -> None:
+    __tracebackhide__ = True
+    start_time = time.time()
+    attempts = 0
+    while True:
+        actual = actual_cb()
+        if actual == expected:
+            return
+        attempts += 1
+        if time.time() - start_time > 10:
+            raise TimeoutError(f"Timed out after 10 seconds. Last actual was: {actual}")
+        time.sleep(0.1)
+
+
+def setup_ws(
+    target: Union[Page, Frame],
+    server: Server,
+    protocol: Union[Literal["blob"], Literal["arraybuffer"]],
+) -> None:
+    target.goto(server.EMPTY_PAGE)
+    target.evaluate(
+        """({ port, binaryType }) => {
+    window.log = [];
+    window.ws = new WebSocket('ws://localhost:' + port + '/ws');
+    window.ws.binaryType = binaryType;
+    window.ws.addEventListener('open', () => window.log.push('open'));
+    window.ws.addEventListener('close', event => window.log.push(`close code=${event.code} reason=${event.reason} wasClean=${event.wasClean}`));
+    window.ws.addEventListener('error', event => window.log.push(`error`));
+    window.ws.addEventListener('message', async event => {
+      let data;
+      if (typeof event.data === 'string')
+        data = event.data;
+      else if (event.data instanceof Blob)
+        data = 'blob:' + event.data.text();
+      else
+        data = 'arraybuffer:' + (new Blob([event.data])).text();
+      window.log.push(`message: data=${data} origin=${event.origin} lastEventId=${event.lastEventId}`);
+    });
+    window.wsOpened = new Promise(f => window.ws.addEventListener('open', () => f()));
+  }""",
+        {"port": server.PORT, "binaryType": protocol},
+    )
+
+
+def test_should_work_with_ws_close(page: Page, server: Server) -> None:
+    route: Optional["WebSocketRoute"] = None
+
+    def _handle_ws(ws: WebSocketRoute) -> None:
+        ws.connect_to_server()
+        nonlocal route
+        route = ws
+
+    page.route_web_socket(re.compile(".*"), _handle_ws)
+
+    with server.expect_websocket() as ws_task:
+        setup_ws(page, server, "blob")
+    page.evaluate("window.wsOpened")
+    ws = ws_task.value
+    assert route
+    route.send("hello")
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=hello origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    closed_event = []
+    ws.events.once("close", lambda code, reason: closed_event.append((code, reason)))
+    route.close(code=3009, reason="oops")
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=hello origin=ws://localhost:{server.PORT} lastEventId=",
+            "close code=3009 reason=oops wasClean=true",
+        ],
+    )
+    assert_equal(lambda: closed_event, [(3009, "oops")])
+
+
+def test_should_pattern_match(page: Page, server: Server) -> None:
+    page.route_web_socket(re.compile(r".*/ws$"), lambda ws: ws.connect_to_server())
+    page.route_web_socket(
+        "**/mock-ws", lambda ws: ws.on_message(lambda message: ws.send("mock-response"))
+    )
+
+    page.goto(server.EMPTY_PAGE)
+    with server.expect_websocket() as ws_info:
+        page.evaluate(
+            """async ({ port }) => {
+                window.log = [];
+                window.ws1 = new WebSocket('ws://localhost:' + port + '/ws');
+                window.ws1.addEventListener('message', event => window.log.push(`ws1:${event.data}`));
+                window.ws2 = new WebSocket('ws://localhost:' + port + '/something/something/mock-ws');
+                window.ws2.addEventListener('message', event => window.log.push(`ws2:${event.data}`));
+                await Promise.all([
+                    new Promise(f => window.ws1.addEventListener('open', f)),
+                    new Promise(f => window.ws2.addEventListener('open', f)),
+                ]);
+            }""",
+            {"port": server.PORT},
+        )
+    ws = ws_info.value
+    ws.events.on("message", lambda payload, isBinary: ws.sendMessage(b"response"))
+
+    page.evaluate("window.ws1.send('request')")
+    assert_equal(lambda: page.evaluate("window.log"), ["ws1:response"])
+
+    page.evaluate("window.ws2.send('request')")
+    assert_equal(
+        lambda: page.evaluate("window.log"), ["ws1:response", "ws2:mock-response"]
+    )
+
+
+def test_should_work_with_server(page: Page, server: Server) -> None:
+    route = None
+
+    def _handle_ws(ws: WebSocketRoute) -> None:
+        server = ws.connect_to_server()
+
+        def _ws_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-respond":
+                ws.send("response")
+                return
+            if message == "to-block":
+                return
+            if message == "to-modify":
+                server.send("modified")
+                return
+            server.send(message)
+
+        ws.on_message(_ws_on_message)
+
+        def _server_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-block":
+                return
+            if message == "to-modify":
+                ws.send("modified")
+                return
+            ws.send(message)
+
+        server.on_message(_server_on_message)
+        server.send("fake")
+        nonlocal route
+        route = ws
+
+    page.route_web_socket(re.compile(".*"), _handle_ws)
+    log = []
+
+    def _once_web_socket_connection(ws: WebSocketProtocol) -> None:
+        ws.events.on(
+            "message", lambda data, is_binary: log.append(f"message: {data.decode()}")
+        )
+        ws.events.on(
+            "close",
+            lambda code, reason: log.append(f"close: code={code} reason={reason}"),
+        )
+
+    server.once_web_socket_connection(_once_web_socket_connection)
+
+    with server.expect_websocket() as ws_info:
+        setup_ws(page, server, "blob")
+    page.evaluate("window.wsOpened")
+    ws = ws_info.value
+    assert_equal(lambda: log, ["message: fake"])
+
+    ws.sendMessage(b"to-modify")
+    ws.sendMessage(b"to-block")
+    ws.sendMessage(b"pass-server")
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    page.evaluate(
+        """() => {
+        window.ws.send('to-respond');
+        window.ws.send('to-modify');
+        window.ws.send('to-block');
+        window.ws.send('pass-client');
+    }"""
+    )
+    assert_equal(
+        lambda: log, ["message: fake", "message: modified", "message: pass-client"]
+    )
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+    assert route
+    route.send("another")
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=modified origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=pass-server origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=another origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+
+    page.evaluate(
+        """() => {
+        window.ws.send('pass-client-2');
+    }"""
+    )
+    assert_equal(
+        lambda: log,
+        [
+            "message: fake",
+            "message: modified",
+            "message: pass-client",
+            "message: pass-client-2",
+        ],
+    )
+
+    page.evaluate(
+        """() => {
+        window.ws.close(3009, 'problem');
+    }"""
+    )
+    assert_equal(
+        lambda: log,
+        [
+            "message: fake",
+            "message: modified",
+            "message: pass-client",
+            "message: pass-client-2",
+            "close: code=3009 reason=problem",
+        ],
+    )
+
+
+def test_should_work_without_server(page: Page, server: Server) -> None:
+    route = None
+
+    def _handle_ws(ws: WebSocketRoute) -> None:
+        def _ws_on_message(message: Union[str, bytes]) -> None:
+            if message == "to-respond":
+                ws.send("response")
+
+        ws.on_message(_ws_on_message)
+        nonlocal route
+        route = ws
+
+    page.route_web_socket(re.compile(".*"), _handle_ws)
+    setup_ws(page, server, "blob")
+
+    page.evaluate(
+        """async () => {
+        await window.wsOpened;
+        window.ws.send('to-respond');
+        window.ws.send('to-block');
+        window.ws.send('to-respond');
+    }"""
+    )
+
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+    assert route
+    route.send("another")
+    # wait for the message to be processed
+    page.wait_for_timeout(100)
+    route.close(code=3008, reason="oops")
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=response origin=ws://localhost:{server.PORT} lastEventId=",
+            f"message: data=another origin=ws://localhost:{server.PORT} lastEventId=",
+            "close code=3008 reason=oops wasClean=true",
+        ],
+    )
+
+
+def test_should_work_with_base_url(browser: Browser, server: Server) -> None:
+    context = browser.new_context(base_url=f"http://localhost:{server.PORT}")
+    page = context.new_page()
+
+    def _handle_ws(ws: WebSocketRoute) -> None:
+        ws.on_message(lambda message: ws.send(message))
+
+    page.route_web_socket("/ws", _handle_ws)
+    setup_ws(page, server, "blob")
+
+    page.evaluate(
+        """async () => {
+        await window.wsOpened;
+        window.ws.send('echo');
+    }"""
+    )
+
+    assert_equal(
+        lambda: page.evaluate("window.log"),
+        [
+            "open",
+            f"message: data=echo origin=ws://localhost:{server.PORT} lastEventId=",
+        ],
+    )
+    context.close()
+
+
+def test_should_work_with_no_trailing_slash(page: Page, server: Server) -> None:
+    log: list[str] = []
+
+    async def handle_ws(ws: WebSocketRoute) -> None:
+        def on_message(message: Union[str, bytes]) -> None:
+            assert isinstance(message, str)
+            log.append(message)
+            ws.send("response")
+
+        ws.on_message(on_message)
+
+    # No trailing slash in the route pattern
+    page.route_web_socket(f"ws://localhost:{server.PORT}", handle_ws)
+
+    page.goto(server.EMPTY_PAGE)
+    page.evaluate(
+        """({ port }) => {
+            window.log = [];
+            // No trailing slash in WebSocket URL
+            window.ws = new WebSocket('ws://localhost:' + port);
+            window.ws.addEventListener('message', event => window.log.push(event.data));
+        }""",
+        {"port": server.PORT},
+    )
+
+    assert_equal(lambda: page.evaluate("window.ws.readyState"), 1)  # WebSocket.OPEN
+    page.evaluate("window.ws.send('query')")
+    assert_equal(lambda: log, ["query"])
+    assert_equal(lambda: page.evaluate("window.log"), ["response"])
diff --git a/tests/sync/test_screencast.py b/tests/sync/test_screencast.py
new file mode 100644
index 000000000..0dcd30530
--- /dev/null
+++ b/tests/sync/test_screencast.py
@@ -0,0 +1,53 @@
+# 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 time
+
+import pytest
+
+from playwright.sync_api import Page
+from tests.server import Server
+
+
+def test_should_expose_screencast_property(page: Page) -> None:
+    assert page.screencast is page.screencast
+
+
+def test_start_should_deliver_frames_via_callback(page: Page, server: Server) -> None:
+    received: list = []
+    page.screencast.start(on_frame=lambda f: received.append(f["data"]))
+    page.goto(server.EMPTY_PAGE)
+    page.evaluate("() => document.body.style.backgroundColor = 'red'")
+    # Force a couple of paint cycles so engines that only emit on visual change
+    # still produce a frame. Mirrors upstream `ensureSomeFrames`.
+    for _ in range(3):
+        page.evaluate(
+            "() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f)))"
+        )
+    page.screenshot()
+    deadline = time.time() + 10
+    while not received and time.time() < deadline:
+        page.wait_for_timeout(100)
+    page.screencast.stop()
+    assert len(received) >= 1
+    assert all(isinstance(d, bytes) and len(d) > 0 for d in received)
+
+
+def test_starting_twice_should_throw(page: Page) -> None:
+    page.screencast.start(on_frame=lambda f: None)
+    try:
+        with pytest.raises(Exception, match="already started"):
+            page.screencast.start(on_frame=lambda f: None)
+    finally:
+        page.screencast.stop()
diff --git a/tests/sync/test_selectors_misc.py b/tests/sync/test_selectors_misc.py
new file mode 100644
index 000000000..ad7ec16ea
--- /dev/null
+++ b/tests/sync/test_selectors_misc.py
@@ -0,0 +1,54 @@
+# 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.
+
+from playwright.sync_api import Page
+
+
+def test_should_work_with_internal_and(page: Page) -> None:
+    page.set_content(
+        """
+        <div class=foo>hello</div><div class=bar>world</div>
+        <span class=foo>hello2</span><span class=bar>world2</span>
+    """
+    )
+    assert (
+        page.eval_on_selector_all(
+            'div >> internal:and="span"', "els => els.map(e => e.textContent)"
+        )
+    ) == []
+    assert (
+        page.eval_on_selector_all(
+            'div >> internal:and=".foo"', "els => els.map(e => e.textContent)"
+        )
+    ) == ["hello"]
+    assert (
+        page.eval_on_selector_all(
+            'div >> internal:and=".bar"', "els => els.map(e => e.textContent)"
+        )
+    ) == ["world"]
+    assert (
+        page.eval_on_selector_all(
+            'span >> internal:and="span"', "els => els.map(e => e.textContent)"
+        )
+    ) == ["hello2", "world2"]
+    assert (
+        page.eval_on_selector_all(
+            '.foo >> internal:and="div"', "els => els.map(e => e.textContent)"
+        )
+    ) == ["hello"]
+    assert (
+        page.eval_on_selector_all(
+            '.bar >> internal:and="span"', "els => els.map(e => e.textContent)"
+        )
+    ) == ["world2"]
diff --git a/tests/sync/test_sync.py b/tests/sync/test_sync.py
index d1b801510..fb9c7c16e 100644
--- a/tests/sync/test_sync.py
+++ b/tests/sync/test_sync.py
@@ -1,6 +1,6 @@
 # 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
 #
@@ -12,26 +12,92 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import multiprocessing
 import os
+from datetime import timedelta
+from typing import Any, Callable, Dict
 
 import pytest
 
-from playwright.sync_api import Browser, Error, Page, TimeoutError, sync_playwright
+from playwright.sync_api import (
+    Browser,
+    BrowserContext,
+    Dialog,
+    Error,
+    Page,
+    TimeoutError,
+    sync_playwright,
+)
+from tests.server import Server
+from tests.utils import TARGET_CLOSED_ERROR_MESSAGE
 
 
-def test_sync_query_selector(page):
+def test_sync_query_selector(page: Page) -> None:
     page.set_content(
         """
     <h1 id="foo">Bar</h1>
     """
     )
+    e1 = page.query_selector("#foo")
+    assert e1
+    e2 = page.query_selector("h1")
+    assert e2
+    assert e1.inner_text() == e2.inner_text()
+
+
+def test_page_repr(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    assert repr(page) == f"<Page url={page.url!r}>"
+
+
+def test_frame_repr(page: Page, server: Server) -> None:
+    page.goto(server.EMPTY_PAGE)
+    assert (
+        repr(page.main_frame)
+        == f"<Frame name={page.main_frame.name} url={page.main_frame.url!r}>"
+    )
+
+
+def test_browser_context_repr(context: BrowserContext) -> None:
+    assert repr(context) == f"<BrowserContext browser={context.browser}>"
+
+
+def test_browser_repr(browser: Browser) -> None:
+    assert (
+        repr(browser)
+        == f"<Browser type={browser._impl_obj._browser_type} version={browser.version}>"
+    )
+
+
+def test_browser_type_repr(browser: Browser) -> None:
+    browser_type = browser._impl_obj._browser_type
     assert (
-        page.query_selector("#foo").inner_text()
-        == page.query_selector("h1").inner_text()
+        repr(browser_type)
+        == f"<BrowserType name={browser_type.name} executable_path={browser_type.executable_path}>"
     )
 
 
-def test_sync_click(page):
+def test_dialog_repr(page: Page) -> None:
+    def on_dialog(dialog: Dialog) -> None:
+        dialog.accept()
+        assert (
+            repr(dialog)
+            == f"<Dialog type={dialog.type} message={dialog.message} default_value={dialog.default_value}>"
+        )
+
+    page.on("dialog", on_dialog)
+    page.evaluate("alert('yo')")
+
+
+def test_console_repr(page: Page) -> None:
+    messages = []
+    page.on("console", lambda m: messages.append(m))
+    page.evaluate('() => console.log("Hello world")')
+    message = messages[0]
+    assert repr(message) == f"<ConsoleMessage type={message.type} text={message.text}>"
+
+
+def test_sync_click(page: Page) -> None:
     page.set_content(
         """
     <button onclick="window.clicked=true">Bar</button>
@@ -41,7 +107,7 @@ def test_sync_click(page):
     assert page.evaluate("()=>window.clicked")
 
 
-def test_sync_nested_query_selector(page):
+def test_sync_nested_query_selector(page: Page) -> None:
     page.set_content(
         """
     <div id="one">
@@ -54,12 +120,15 @@ def test_sync_nested_query_selector(page):
     """
     )
     e1 = page.query_selector("#one")
+    assert e1
     e2 = e1.query_selector(".two")
+    assert e2
     e3 = e2.query_selector("label")
+    assert e3
     assert e3.inner_text() == "MyValue"
 
 
-def test_sync_handle_multiple_pages(context):
+def test_sync_handle_multiple_pages(context: BrowserContext) -> None:
     page1 = context.new_page()
     page2 = context.new_page()
     assert len(context.pages) == 2
@@ -76,27 +145,31 @@ def test_sync_handle_multiple_pages(context):
             page.content()
 
 
-def test_sync_wait_for_event(page: Page, server):
+def test_sync_wait_for_event(page: Page, server: Server) -> None:
     with page.expect_event("popup", timeout=10000) as popup:
         page.evaluate("(url) => window.open(url)", server.EMPTY_PAGE)
     assert popup.value
 
 
-def test_sync_wait_for_event_raise(page):
-    with pytest.raises(Error):
-        with page.expect_event("popup", timeout=500) as popup:
+def test_sync_wait_for_event_raise(page: Page) -> None:
+    with pytest.raises(AssertionError):
+        with page.expect_event("popup", timeout=500):
             assert False
-        assert popup.value is None
+
+    with pytest.raises(Error) as exc_info:
+        with page.expect_event("popup", timeout=500):
+            page.wait_for_timeout(1_000)
+    assert "Timeout 500ms exceeded" in exc_info.value.message
 
 
-def test_sync_make_existing_page_sync(page):
+def test_sync_make_existing_page_sync(page: Page) -> None:
     page = page
     assert page.evaluate("() => ({'playwright': true})") == {"playwright": True}
     page.set_content("<h1>myElement</h1>")
     page.wait_for_selector("text=myElement")
 
 
-def test_sync_network_events(page, server):
+def test_sync_network_events(page: Page, server: Server) -> None:
     server.set_route(
         "/hello-world",
         lambda request: (
@@ -122,21 +195,25 @@ def test_sync_network_events(page, server):
     ]
 
 
-def test_console_should_work(page):
+def test_console_should_work(page: Page, browser_name: str) -> None:
     messages = []
     page.once("console", lambda m: messages.append(m))
-    page.evaluate('() => console.log("hello", 5, {foo: "bar"})'),
+    page.evaluate('() => console.log("hello", 5, {foo: "bar"})')
     assert len(messages) == 1
     message = messages[0]
-    assert message.text == "hello 5 JSHandle@object"
-    assert str(message) == "hello 5 JSHandle@object"
+    if browser_name != "firefox":
+        assert message.text == "hello 5 {foo: bar}"
+        assert str(message) == "hello 5 {foo: bar}"
+    else:
+        assert message.text == "hello 5 JSHandle@object"
+        assert str(message) == "hello 5 JSHandle@object"
     assert message.type == "log"
     assert message.args[0].json_value() == "hello"
     assert message.args[1].json_value() == 5
     assert message.args[2].json_value() == {"foo": "bar"}
 
 
-def test_sync_download(browser: Browser, server):
+def test_sync_download(browser: Browser, server: Server) -> None:
     server.set_route(
         "/downloadWithFilename",
         lambda request: (
@@ -160,7 +237,7 @@ def test_sync_download(browser: Browser, server):
     page.close()
 
 
-def test_sync_workers_page_workers(page: Page, server):
+def test_sync_workers_page_workers(page: Page, server: Server) -> None:
     with page.expect_event("worker") as event_worker:
         page.goto(server.PREFIX + "/worker/worker.html")
     assert event_worker.value
@@ -173,31 +250,36 @@ def test_sync_workers_page_workers(page: Page, server):
     assert len(page.workers) == 0
 
 
-def test_sync_playwright_multiple_times():
+def test_sync_playwright_multiple_times() -> None:
     with pytest.raises(Error) as exc:
         with sync_playwright() as pw:
             assert pw.chromium
-    assert "Can only run one Playwright at a time." in exc.value.message
+    assert (
+        "It looks like you are using Playwright Sync API inside the asyncio loop."
+        in exc.value.message
+    )
 
 
-def test_sync_set_default_timeout(page):
+def test_sync_set_default_timeout(page: Page) -> None:
     page.set_default_timeout(1)
     with pytest.raises(TimeoutError) as exc:
         page.wait_for_function("false")
     assert "Timeout 1ms exceeded." in exc.value.message
 
 
-def test_close_should_reject_all_promises(context):
+def test_close_should_reject_all_promises(
+    context: BrowserContext, sync_gather: Callable
+) -> None:
     new_page = context.new_page()
     with pytest.raises(Error) as exc_info:
-        new_page._gather(
+        sync_gather(
             lambda: new_page.evaluate("() => new Promise(r => {})"),
             lambda: new_page.close(),
         )
-    assert "Protocol error" in exc_info.value.message
+    assert TARGET_CLOSED_ERROR_MESSAGE in exc_info.value.message
 
 
-def test_expect_response_should_work(page: Page, server):
+def test_expect_response_should_work(page: Page, server: Server) -> None:
     with page.expect_response("**/*") as resp:
         page.goto(server.EMPTY_PAGE)
     assert resp.value
@@ -205,3 +287,80 @@ def test_expect_response_should_work(page: Page, server):
     assert resp.value.status == 200
     assert resp.value.ok
     assert resp.value.request
+
+
+def test_expect_response_should_not_hang_when_predicate_throws(page: Page) -> None:
+    with pytest.raises(Exception, match="Oops!"):
+        with page.expect_response("**/*"):
+            raise Exception("Oops!")
+
+
+def test_expect_response_should_use_context_timeout(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    page.goto(server.EMPTY_PAGE)
+
+    context.set_default_timeout(1_000)
+    with pytest.raises(Error) as exc_info:
+        with page.expect_response("https://playwright.dev"):
+            pass
+    assert exc_info.type is TimeoutError
+    assert "Timeout 1000ms exceeded" in exc_info.value.message
+
+
+def _test_sync_playwright_stop_multiple_times() -> None:
+    playwright = sync_playwright().start()
+    playwright.stop()
+    playwright.stop()
+
+
+def test_sync_playwright_stop_multiple_times() -> None:
+    p = multiprocessing.Process(target=_test_sync_playwright_stop_multiple_times)
+    p.start()
+    p.join()
+    assert p.exitcode == 0
+
+
+def _test_call_sync_method_after_playwright_close_with_own_loop(
+    browser_name: str,
+    launch_arguments: Dict[str, Any],
+    empty_page: str,
+) -> None:
+    playwright = sync_playwright().start()
+    browser = playwright[browser_name].launch(**launch_arguments)
+    context = browser.new_context()
+    page = context.new_page()
+    page.goto(empty_page)
+    playwright.stop()
+    with pytest.raises(Error) as exc:
+        page.evaluate("1+1")
+    assert "Event loop is closed! Is Playwright already stopped?" in str(exc.value)
+
+
+def test_call_sync_method_after_playwright_close_with_own_loop(
+    server: Server, browser_name: str, launch_arguments: Dict[str, Any]
+) -> None:
+    p = multiprocessing.Process(
+        target=_test_call_sync_method_after_playwright_close_with_own_loop,
+        args=[browser_name, launch_arguments, server.EMPTY_PAGE],
+    )
+    p.start()
+    p.join()
+    assert p.exitcode == 0
+
+
+def test_should_return_proper_api_name_on_error(page: Page) -> None:
+    try:
+        page.evaluate("does_not_exist")
+
+        assert (
+            False
+        ), "Accessing undefined JavaScript variable should have thrown exception"
+    except Exception as error:
+        # Each browser returns slightly different error messages, but they should all start with "Page.evaluate:", because that was the Playwright method where the error originated
+        assert str(error).startswith("Page.evaluate:")
+
+
+def test_click_should_accept_timedelta_for_timeout(page: Page) -> None:
+    with pytest.raises(TimeoutError, match="Timeout 1ms exceeded"):
+        page.click("does-not-exist", timeout=timedelta(milliseconds=1))
diff --git a/tests/sync/test_tap.py b/tests/sync/test_tap.py
index 560d3be96..762698b04 100644
--- a/tests/sync/test_tap.py
+++ b/tests/sync/test_tap.py
@@ -12,19 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Generator, Optional
+
 import pytest
 
-from playwright.sync_api import ElementHandle, JSHandle
+from playwright.sync_api import Browser, BrowserContext, ElementHandle, JSHandle, Page
 
 
 @pytest.fixture
-def context(browser):
+def context(browser: Browser) -> Generator[BrowserContext, None, None]:
     context = browser.new_context(has_touch=True)
     yield context
     context.close()
 
 
-def test_should_send_all_of_the_correct_events(page):
+def test_should_send_all_of_the_correct_events(page: Page) -> None:
     page.set_content(
         """
             <div id="a" style="background: lightblue; width: 50px; height: 50px">a</div>
@@ -52,7 +54,7 @@ def test_should_send_all_of_the_correct_events(page):
     ]
 
 
-def test_should_not_send_mouse_events_touchstart_is_canceled(page):
+def test_should_not_send_mouse_events_touchstart_is_canceled(page: Page) -> None:
     page.set_content("hello world")
     page.evaluate(
         """() => {
@@ -74,7 +76,7 @@ def test_should_not_send_mouse_events_touchstart_is_canceled(page):
     ]
 
 
-def test_should_not_send_mouse_events_touchend_is_canceled(page):
+def test_should_not_send_mouse_events_touchend_is_canceled(page: Page) -> None:
     page.set_content("hello world")
     page.evaluate(
         """() => {
@@ -96,7 +98,8 @@ def test_should_not_send_mouse_events_touchend_is_canceled(page):
     ]
 
 
-def track_events(target: ElementHandle) -> JSHandle:
+def track_events(target: Optional[ElementHandle]) -> JSHandle:
+    assert target
     return target.evaluate_handle(
         """target => {
             const events = [];
diff --git a/tests/sync/test_tracing.py b/tests/sync/test_tracing.py
new file mode 100644
index 000000000..badbe7e81
--- /dev/null
+++ b/tests/sync/test_tracing.py
@@ -0,0 +1,443 @@
+# 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 json
+import re
+import threading
+import zipfile
+from pathlib import Path
+from typing import Callable, ContextManager
+
+from playwright.sync_api import (
+    Browser,
+    BrowserContext,
+    BrowserType,
+    Page,
+    Playwright,
+    Response,
+    expect,
+)
+from tests.server import Server
+
+from .conftest import TraceViewerPage
+
+
+def test_browser_context_output_trace(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    context = browser.new_context()
+    context.tracing.start(screenshots=True, snapshots=True)
+    page = context.new_page()
+    page.goto(server.PREFIX + "/grid.html")
+    context.tracing.stop(path=tmp_path / "trace.zip")
+    assert Path(tmp_path / "trace.zip").exists()
+    context.close()
+
+
+def test_start_stop(browser: Browser) -> None:
+    context = browser.new_context()
+    context.tracing.start()
+    context.tracing.stop()
+    context.close()
+
+
+def test_browser_context_should_not_throw_when_stopping_without_start_but_not_exporting(
+    context: BrowserContext,
+) -> None:
+    context.tracing.stop()
+
+
+def test_browser_context_output_trace_chunk(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    context = browser.new_context()
+    context.tracing.start(screenshots=True, snapshots=True)
+    page = context.new_page()
+    page.goto(server.PREFIX + "/grid.html")
+    button = page.locator(".box").first
+
+    context.tracing.start_chunk(title="foo")
+    button.click()
+    context.tracing.stop_chunk(path=tmp_path / "trace1.zip")
+    assert Path(tmp_path / "trace1.zip").exists()
+
+    context.tracing.start_chunk(title="foo")
+    button.click()
+    context.tracing.stop_chunk(path=tmp_path / "trace2.zip")
+    assert Path(tmp_path / "trace2.zip").exists()
+    context.close()
+
+
+def test_should_collect_sources(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
+) -> None:
+    context.tracing.start(sources=True)
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<button>Click</button>")
+
+    def my_method_outer() -> None:
+        def my_method_inner() -> None:
+            page.get_by_text("Click").click()
+
+        my_method_inner()
+
+    my_method_outer()
+    path = tmp_path / "trace.zip"
+    context.tracing.stop(path=path)
+
+    with show_trace_viewer(path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+            ]
+        )
+        trace_viewer.show_source_tab()
+        # Check that stack frames are shown (they might be anonymous in Python)
+        expect(trace_viewer.stack_frames).to_contain_text(
+            [
+                re.compile(r"my_method_inner"),
+                re.compile(r"my_method_outer"),
+                re.compile(r"test_should_collect_sources"),
+            ]
+        )
+
+        trace_viewer.select_action("Set content")
+        # Check that the source file is shown
+        expect(trace_viewer.page.locator(".source-tab-file-name")).to_have_attribute(
+            "title", re.compile(r".*test_.*\.py")
+        )
+        expect(trace_viewer.page.locator(".source-line-running")).to_contain_text(
+            'page.set_content("<button>Click</button>")'
+        )
+
+
+def test_should_collect_trace_with_resources_but_no_js(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
+) -> None:
+    context.tracing.start(screenshots=True, snapshots=True)
+    page.goto(server.PREFIX + "/frames/frame.html")
+    page.set_content("<button>Click</button>")
+    page.click('"Click"')
+    page.mouse.move(20, 20)
+    page.mouse.dblclick(30, 30)
+    page.request.get(server.EMPTY_PAGE)
+    page.keyboard.insert_text("abc")
+    page.wait_for_timeout(2000)  # Give it some time to produce screenshots.
+    page.route("**/empty.html", lambda route: route.continue_())
+    page.goto(server.EMPTY_PAGE)
+    page.goto(server.PREFIX + "/one-style.html")
+    page.close()
+    trace_file_path = tmp_path / "trace.zip"
+    context.tracing.stop(path=trace_file_path)
+
+    with show_trace_viewer(trace_file_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/frames/frame\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+                re.compile(r"Mouse move"),
+                re.compile(r"Double click"),
+                re.compile(r"GET \"/empty\.html\""),
+                re.compile(r'Insert "abc"'),
+                re.compile(r"Wait for timeout"),
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r'Navigate to "/one-style\.html"'),
+                re.compile(r"Close"),
+            ]
+        )
+
+        trace_viewer.select_action("Set content")
+        expect(trace_viewer.page.locator(".browser-frame-address-bar")).to_have_text(
+            server.PREFIX + "/frames/frame.html"
+        )
+        frame = trace_viewer.snapshot_frame("Set content", 0, False)
+        expect(frame.locator("button")).to_have_text("Click")
+
+
+def test_should_correctly_determine_sync_apiname(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable,
+) -> None:
+    context.tracing.start(screenshots=True, snapshots=True)
+
+    received_response = threading.Event()
+
+    def _handle_response(response: Response) -> None:
+        response.request.all_headers()
+        response.text()
+        received_response.set()
+
+    page.once("response", _handle_response)
+    page.goto(server.PREFIX + "/grid.html")
+    received_response.wait()
+
+    page.close()
+    trace_file_path = tmp_path / "trace.zip"
+    context.tracing.stop(path=trace_file_path)
+
+    with show_trace_viewer(trace_file_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/grid\.html"'),
+                re.compile(r"Close"),
+            ]
+        )
+
+
+def test_should_collect_two_traces(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
+) -> None:
+    context.tracing.start(screenshots=True, snapshots=True)
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<button>Click</button>")
+    page.click('"Click"')
+    tracing1_path = tmp_path / "trace1.zip"
+    context.tracing.stop(path=tracing1_path)
+
+    context.tracing.start(screenshots=True, snapshots=True)
+    page.dblclick('"Click"')
+    page.close()
+    tracing2_path = tmp_path / "trace2.zip"
+    context.tracing.stop(path=tracing2_path)
+
+    with show_trace_viewer(tracing1_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r"Click"),
+            ]
+        )
+
+    with show_trace_viewer(tracing2_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r"Double click"),
+                re.compile(r"Close"),
+            ]
+        )
+
+
+def test_should_work_with_playwright_context_managers(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
+) -> None:
+    context.tracing.start(screenshots=True, snapshots=True)
+    page.goto(server.EMPTY_PAGE)
+    page.set_content("<button>Click</button>")
+    with page.expect_console_message() as message_info:
+        page.evaluate('() => console.log("hello")')
+        page.click('"Click"')
+    assert (message_info.value).text == "hello"
+
+    with page.expect_popup():
+        page.evaluate("window._popup = window.open(document.location.href)")
+    trace_file_path = tmp_path / "trace.zip"
+    context.tracing.stop(path=trace_file_path)
+
+    with show_trace_viewer(trace_file_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r"Set content"),
+                re.compile(r'Wait for event "page\.expect_event\(console\)"'),
+                re.compile(r"Evaluate"),
+                re.compile(r"Click"),
+                re.compile(r'Wait for event "page\.expect_event\(popup\)"'),
+                re.compile(r"Evaluate"),
+            ]
+        )
+
+
+def test_should_display_wait_for_load_state_even_if_did_not_wait_for_it(
+    context: BrowserContext,
+    page: Page,
+    server: Server,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
+) -> None:
+    context.tracing.start(screenshots=True, snapshots=True)
+
+    page.goto(server.EMPTY_PAGE)
+    page.wait_for_load_state("load")
+    page.wait_for_load_state("load")
+
+    trace_file_path = tmp_path / "trace.zip"
+    context.tracing.stop(path=trace_file_path)
+
+    with show_trace_viewer(trace_file_path) as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/empty\.html"'),
+                re.compile(r'Wait for event "frame\.wait_for_load_state"'),
+                re.compile(r'Wait for event "frame\.wait_for_load_state"'),
+            ]
+        )
+
+
+def test_should_respect_traces_dir_and_name(
+    browser_type: BrowserType,
+    server: Server,
+    tmp_path: Path,
+    launch_arguments: dict,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
+) -> None:
+    traces_dir = tmp_path / "traces"
+    browser = browser_type.launch(traces_dir=traces_dir, **launch_arguments)
+    context = browser.new_context()
+    page = context.new_page()
+
+    context.tracing.start(name="name1", snapshots=True)
+    page.goto(server.PREFIX + "/one-style.html")
+    context.tracing.stop_chunk(path=tmp_path / "trace1.zip")
+    assert (traces_dir / "name1.trace").exists()
+    assert (traces_dir / "name1.network").exists()
+
+    context.tracing.start_chunk(name="name2")
+    page.goto(server.PREFIX + "/har.html")
+    context.tracing.stop(path=tmp_path / "trace2.zip")
+    assert (traces_dir / "name2.trace").exists()
+    assert (traces_dir / "name2.network").exists()
+
+    browser.close()
+
+    with show_trace_viewer(tmp_path / "trace1.zip") as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/one-style\.html"'),
+            ]
+        )
+        frame = trace_viewer.snapshot_frame('Navigate to "/one-style.html"', 0, False)
+        expect(frame.locator("body")).to_have_css(
+            "background-color", "rgb(255, 192, 203)"
+        )
+        expect(frame.locator("body")).to_have_text("hello, world!")
+
+    with show_trace_viewer(tmp_path / "trace2.zip") as trace_viewer:
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r'Navigate to "/har\.html"'),
+            ]
+        )
+        frame = trace_viewer.snapshot_frame('Navigate to "/har.html"', 0, False)
+        expect(frame.locator("body")).to_have_css(
+            "background-color", "rgb(255, 192, 203)"
+        )
+        expect(frame.locator("body")).to_have_text("hello, world!")
+
+
+def test_should_show_tracing_group_in_action_list(
+    context: BrowserContext,
+    tmp_path: Path,
+    show_trace_viewer: Callable[[Path], ContextManager[TraceViewerPage]],
+) -> None:
+    context.tracing.start()
+    page = context.new_page()
+
+    context.tracing.group("outer group")
+    page.goto("data:text/html,<!DOCTYPE html><body><div>Hello world</div></body>")
+    context.tracing.group("inner group 1")
+    page.locator("body").click()
+    context.tracing.group_end()
+    context.tracing.group("inner group 2")
+    page.get_by_text("Hello").is_visible()
+    context.tracing.group_end()
+    context.tracing.group_end()
+
+    trace_path = tmp_path / "trace.zip"
+    context.tracing.stop(path=trace_path)
+
+    with show_trace_viewer(trace_path) as trace_viewer:
+        trace_viewer.expand_action("inner group 1")
+        expect(trace_viewer.action_titles).to_have_text(
+            [
+                re.compile(r"Create page"),
+                re.compile(r"outer group"),
+                re.compile(r"Navigate to \"data:\""),
+                re.compile(r"inner group 1"),
+                re.compile(r"Click"),
+                re.compile(r"inner group 2"),
+            ]
+        )
+
+
+def test_should_start_and_stop_har(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    context = browser.new_context()
+    page = context.new_page()
+    har_path = tmp_path / "test.har"
+    context.tracing.start_har(path=har_path, content="embed", mode="full")
+    page.goto(server.PREFIX + "/empty.html")
+    context.tracing.stop_har()
+    context.close()
+    assert har_path.exists()
+    assert har_path.stat().st_size > 0
+
+
+def test_should_record_a_har_with_options(
+    browser: Browser, server: Server, tmp_path: Path
+) -> None:
+    context = browser.new_context()
+    har_path = tmp_path / "tracing.har"
+    context.tracing.start_har(
+        path=har_path, mode="minimal", url_filter="**/one-style.css"
+    )
+    page = context.new_page()
+    page.goto(server.PREFIX + "/one-style.html")
+    context.tracing.stop_har()
+    context.close()
+
+    log = json.loads(har_path.read_text())["log"]
+    urls = [e["request"]["url"] for e in log["entries"]]
+    assert urls == [server.PREFIX + "/one-style.css"]
+    assert log["entries"][0]["request"]["bodySize"] == -1
+
+
+def test_should_record_a_zipped_har_for_apirequestcontext(
+    playwright: Playwright, server: Server, tmp_path: Path
+) -> None:
+    request = playwright.request.new_context()
+    har_path = tmp_path / "tracing.har.zip"
+    request.tracing.start_har(path=har_path, content="attach")
+    request.get(server.PREFIX + "/simple.json")
+    request.tracing.stop_har()
+    request.dispose()
+
+    with zipfile.ZipFile(har_path) as zf:
+        log = json.loads(zf.read("har.har"))["log"]
+    assert any(
+        e["request"]["url"] == server.PREFIX + "/simple.json" for e in log["entries"]
+    )
diff --git a/tests/sync/test_unroute_behavior.py b/tests/sync/test_unroute_behavior.py
new file mode 100644
index 000000000..f37146582
--- /dev/null
+++ b/tests/sync/test_unroute_behavior.py
@@ -0,0 +1,61 @@
+# 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.
+
+from playwright.sync_api import BrowserContext, Page, Route
+from tests.server import Server
+from tests.utils import must
+
+
+def test_context_unroute_all_removes_all_handlers(
+    page: Page, context: BrowserContext, server: Server
+) -> None:
+    context.route(
+        "**/*",
+        lambda route: route.abort(),
+    )
+    context.route(
+        "**/empty.html",
+        lambda route: route.abort(),
+    )
+    context.unroute_all()
+    page.goto(server.EMPTY_PAGE)
+
+
+def test_page_unroute_all_removes_all_routes(page: Page, server: Server) -> None:
+    page.route(
+        "**/*",
+        lambda route: route.abort(),
+    )
+    page.route(
+        "**/empty.html",
+        lambda route: route.abort(),
+    )
+    page.unroute_all()
+    response = must(page.goto(server.EMPTY_PAGE))
+    assert response.ok
+
+
+def test_page_route_returns_disposable(page: Page, server: Server) -> None:
+    intercepted: list = []
+
+    def handler(route: Route) -> None:
+        intercepted.append(route.request.url)
+        route.continue_()
+
+    with page.route("**/*", handler):
+        page.goto(server.EMPTY_PAGE)
+        assert any(server.EMPTY_PAGE in url for url in intercepted)
+    intercepted.clear()
+    page.goto(server.EMPTY_PAGE)
+    assert intercepted == []
diff --git a/tests/sync/test_video.py b/tests/sync/test_video.py
index a8d303f03..3ae1daa21 100644
--- a/tests/sync/test_video.py
+++ b/tests/sync/test_video.py
@@ -13,39 +13,103 @@
 # limitations under the License.
 
 import os
+from pathlib import Path
+from typing import Dict
 
+import pytest
 
-def test_should_expose_video_path(browser, tmpdir, server):
-    page = browser.new_page(record_video_dir=tmpdir, record_video_size=(100, 200))
+from playwright.sync_api import Browser, BrowserType, Error
+from tests.server import Server
+
+
+def test_should_expose_video_path(
+    browser: Browser, tmp_path: Path, server: Server
+) -> None:
+    page = browser.new_page(
+        record_video_dir=tmp_path, record_video_size={"width": 100, "height": 200}
+    )
     page.goto(server.PREFIX + "/grid.html")
-    path = page.video.path()
-    assert str(tmpdir) in path
+    video = page.video
+    assert video
+    path = video.path()
+    assert repr(page.video) == f"<Video page={page}>"
+    assert str(tmp_path) in str(path)
+    page.wait_for_timeout(1000)
     page.context.close()
 
 
-def test_video_should_exist(browser, tmpdir, server):
-    page = browser.new_page(record_video_dir=tmpdir)
+def test_video_should_exist(browser: Browser, tmp_path: Path, server: Server) -> None:
+    page = browser.new_page(record_video_dir=tmp_path)
     page.goto(server.PREFIX + "/grid.html")
-    path = page.video.path()
-    assert str(tmpdir) in path
+    video = page.video
+    assert video
+    path = video.path()
+    assert str(tmp_path) in str(path)
+    page.wait_for_timeout(1000)
     page.context.close()
     assert os.path.exists(path)
 
 
-def test_record_video_to_path(browser, tmpdir, server):
-    page = browser.new_page(record_video_dir=tmpdir)
+def test_record_video_to_path(browser: Browser, tmp_path: Path, server: Server) -> None:
+    page = browser.new_page(record_video_dir=tmp_path)
     page.goto(server.PREFIX + "/grid.html")
-    path = page.video.path()
-    assert str(tmpdir) in path
+    video = page.video
+    assert video
+    path = video.path()
+    assert str(tmp_path) in str(path)
+    page.wait_for_timeout(1000)
     page.context.close()
     assert os.path.exists(path)
 
 
-def test_record_video_to_path_persistent(browser_type, tmpdir, server):
-    context = browser_type.launch_persistent_context(tmpdir, record_video_dir=tmpdir)
+def test_record_video_to_path_persistent(
+    browser_type: BrowserType, tmp_path: Path, server: Server, launch_arguments: Dict
+) -> None:
+    context = browser_type.launch_persistent_context(
+        tmp_path, **launch_arguments, record_video_dir=tmp_path
+    )
     page = context.pages[0]
     page.goto(server.PREFIX + "/grid.html")
-    path = page.video.path()
-    assert str(tmpdir) in path
+    video = page.video
+    assert video
+    path = video.path()
+    assert str(tmp_path) in str(path)
+    page.wait_for_timeout(1000)
     context.close()
     assert os.path.exists(path)
+
+
+def test_record_video_can_get_video_path_immediately(
+    browser_type: BrowserType, tmp_path: Path, launch_arguments: Dict
+) -> None:
+    context = browser_type.launch_persistent_context(
+        tmp_path, **launch_arguments, record_video_dir=tmp_path
+    )
+    page = context.pages[0]
+    video = page.video
+    assert video
+    path = video.path()
+    assert str(tmp_path) in str(path)
+    page.wait_for_timeout(1000)
+    context.close()
+    assert os.path.exists(path)
+
+
+def test_should_error_if_page_not_closed_before_save_as(
+    browser: Browser, tmp_path: Path, server: Server
+) -> None:
+    page = browser.new_page(record_video_dir=tmp_path)
+    page.goto(server.PREFIX + "/grid.html")
+    page.wait_for_timeout(1000)  # Give it some time to record.
+    out_path = tmp_path / "some-video.webm"
+    with pytest.raises(Error) as err:
+        video = page.video
+        assert video
+        video.save_as(out_path)
+    assert video
+    assert "Page is not yet closed. Close the page prior to calling save_as" in str(err)
+    assert not os.path.exists(out_path)
+    page.close()
+
+    video.save_as(out_path)
+    assert os.path.exists(out_path)
diff --git a/tests/sync/utils.py b/tests/sync/utils.py
new file mode 100644
index 000000000..64cc51243
--- /dev/null
+++ b/tests/sync/utils.py
@@ -0,0 +1,74 @@
+# 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 re
+from typing import Any, List, cast
+
+from playwright.sync_api import Error, Frame, Page, Selectors, ViewportSize
+
+
+class Utils:
+    def attach_frame(self, page: Page, frame_id: str, url: str) -> Frame:
+        handle = page.evaluate_handle(
+            """async ({ frame_id, url }) => {
+                const frame = document.createElement('iframe');
+                frame.src = url;
+                frame.id = frame_id;
+                document.body.appendChild(frame);
+                await new Promise(x => frame.onload = x);
+                return frame;
+            }""",
+            {"frame_id": frame_id, "url": url},
+        )
+        element_handle = handle.as_element()
+        assert element_handle
+        frame = element_handle.content_frame()
+        assert frame
+        return frame
+
+    def detach_frame(self, page: Page, frame_id: str) -> None:
+        page.evaluate(
+            "frame_id => document.getElementById(frame_id).remove()", frame_id
+        )
+
+    def dump_frames(self, frame: Frame, indentation: str = "") -> List[str]:
+        indentation = indentation or ""
+        description = re.sub(r":\d+/", ":<PORT>/", frame.url)
+        if frame.name:
+            description += " (" + frame.name + ")"
+        result = [indentation + description]
+        sorted_frames = sorted(
+            frame.child_frames, key=lambda frame: frame.url + frame.name
+        )
+        for child in sorted_frames:
+            result = result + utils.dump_frames(child, "    " + indentation)
+        return result
+
+    def verify_viewport(self, page: Page, width: int, height: int) -> None:
+        assert cast(ViewportSize, page.viewport_size)["width"] == width
+        assert cast(ViewportSize, page.viewport_size)["height"] == height
+        assert page.evaluate("window.innerWidth") == width
+        assert page.evaluate("window.innerHeight") == height
+
+    def register_selector_engine(
+        self, selectors: Selectors, *args: Any, **kwargs: Any
+    ) -> None:
+        try:
+            selectors.register(*args, **kwargs)
+        except Error as exc:
+            if "has been already registered" not in exc.message:
+                raise exc
+
+
+utils = Utils()
diff --git a/tests/test_generation_scripts.py b/tests/test_generation_scripts.py
deleted file mode 100644
index eeda5773f..000000000
--- a/tests/test_generation_scripts.py
+++ /dev/null
@@ -1,29 +0,0 @@
-import sys
-from io import StringIO
-from unittest.mock import patch
-
-import pytest
-
-CAN_RUN_GENERATION_SCRIPT = sys.version_info >= (3, 8)
-
-if CAN_RUN_GENERATION_SCRIPT:
-    from scripts.generate_async_api import main as generate_async_api
-    from scripts.generate_sync_api import main as generate_sync_api
-
-
-@pytest.mark.skipif(
-    not CAN_RUN_GENERATION_SCRIPT, reason="requires python3.8 or higher"
-)
-@patch("sys.stderr", new_callable=StringIO)
-@patch("sys.stdout", new_callable=StringIO)
-def test_generate_sync_api(stdout, stderr):
-    generate_sync_api()
-
-
-@pytest.mark.skipif(
-    not CAN_RUN_GENERATION_SCRIPT, reason="requires python3.8 or higher"
-)
-@patch("sys.stderr", new_callable=StringIO)
-@patch("sys.stdout", new_callable=StringIO)
-def test_generate_async_api(stdout, stderr):
-    generate_async_api()
diff --git a/tests/test_installation.py b/tests/test_installation.py
new file mode 100644
index 000000000..e002a477c
--- /dev/null
+++ b/tests/test_installation.py
@@ -0,0 +1,53 @@
+# 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 os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from venv import EnvBuilder
+
+
+def test_install(tmp_path: Path, browser_name: str) -> None:
+    env_dir = tmp_path / "env"
+    env = EnvBuilder(with_pip=True)
+    env.create(env_dir=env_dir)
+    context = env.ensure_directories(env_dir)
+    root = Path(__file__).parent.parent.resolve()
+    if sys.platform == "win32":
+        wheelpath = list((root / "dist").glob("playwright*win_amd64*.whl"))[0]
+    elif sys.platform == "linux":
+        wheelpath = list((root / "dist").glob("playwright*manylinux1*.whl"))[0]
+    elif sys.platform == "darwin":
+        wheelpath = list((root / "dist").glob("playwright*macosx_*.whl"))[0]
+    subprocess.check_output(
+        [
+            context.env_exe,
+            "-m",
+            "pip",
+            "install",
+            str(wheelpath),
+        ]
+    )
+    environ = os.environ.copy()
+    environ["PLAYWRIGHT_BROWSERS_PATH"] = str(tmp_path)
+    subprocess.check_output(
+        [context.env_exe, "-m", "playwright", "install", browser_name], env=environ
+    )
+    shutil.copyfile(root / "tests" / "assets" / "client.py", tmp_path / "main.py")
+    subprocess.check_output(
+        [context.env_exe, str(tmp_path / "main.py"), browser_name], env=environ
+    )
+    assert (tmp_path / f"{browser_name}.png").exists()
diff --git a/tests/test_reference_count_async.py b/tests/test_reference_count_async.py
new file mode 100644
index 000000000..5eb1c28a1
--- /dev/null
+++ b/tests/test_reference_count_async.py
@@ -0,0 +1,134 @@
+# 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 gc
+import os
+import tempfile
+from collections import defaultdict
+from typing import Any
+
+import objgraph
+import pytest
+
+from playwright.async_api import async_playwright
+from tests.server import Server
+
+
+@pytest.mark.asyncio
+async def test_memory_objects(server: Server, browser_name: str) -> None:
+    async with async_playwright() as p:
+        browser = await p[browser_name].launch()
+        page = await browser.new_page()
+        await page.goto(server.EMPTY_PAGE)
+
+        page.on("dialog", lambda dialog: dialog.dismiss())
+        for _ in range(100):
+            await page.evaluate("""async () => alert()""")
+
+        await page.route("**/*", lambda route, _: route.fulfill(body="OK"))
+
+        def handle_network_response_received(event: Any) -> None:
+            event["__pw__is_last_network_response_received_event"] = True
+
+        if browser_name == "chromium":
+            # https://github.com/microsoft/playwright-python/issues/1602
+            client = await page.context.new_cdp_session(page)
+            await client.send("Network.enable")
+
+            client.on(
+                "Network.responseReceived",
+                handle_network_response_received,
+            )
+
+        for _ in range(100):
+            response = await page.evaluate("""async () => (await fetch("/")).text()""")
+            assert response == "OK"
+
+        await browser.close()
+
+    gc.collect()
+
+    pw_objects: defaultdict = defaultdict(int)
+    for o in objgraph.by_type("dict"):
+        assert isinstance(o, dict)
+        name = o.get("_type")
+        # https://github.com/microsoft/playwright-python/issues/1602
+        if o.get("__pw__is_last_network_response_received_event", False):
+            assert False
+        if not name:
+            continue
+        pw_objects[name] += 1
+
+    assert "Dialog" not in pw_objects
+    assert "Request" not in pw_objects
+    assert "Route" not in pw_objects
+
+
+@pytest.mark.asyncio
+async def test_tracing_should_not_leak_protocol_callbacks(browser_name: str) -> None:
+    """
+    Regression test for https://github.com/microsoft/playwright-python/issues/2977
+
+    This test ensures that ProtocolCallback objects don't accumulate when tracing is enabled.
+    The memory leak occurred because no_reply callbacks were created with circular references
+    but never cleaned up.
+    """
+
+    def count_protocol_callbacks() -> int:
+        """Count ProtocolCallback objects in memory."""
+        gc.collect()
+        count = 0
+        for obj in gc.get_objects():
+            if (
+                hasattr(obj, "__class__")
+                and obj.__class__.__name__ == "ProtocolCallback"
+            ):
+                count += 1
+        return count
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        trace_file = os.path.join(temp_dir, "test_trace.zip")
+
+        async with async_playwright() as p:
+            browser = await p[browser_name].launch()
+            context = await browser.new_context()
+
+            # Start tracing to trigger the creation of no_reply callbacks
+            await context.tracing.start(screenshots=True, snapshots=True)
+
+            initial_count = count_protocol_callbacks()
+
+            # Perform operations that would create tracing callbacks
+            for _ in range(3):
+                page = await context.new_page()
+                await page.goto("data:text/html,<h1>Test Page</h1>")
+                await page.wait_for_load_state("networkidle")
+                await page.evaluate(
+                    "document.querySelector('h1').textContent = 'Modified'"
+                )
+                await page.close()
+
+            # Stop tracing
+            await context.tracing.stop(path=trace_file)
+            await browser.close()
+
+    # Force garbage collection and check callback count
+    gc.collect()
+    final_count = count_protocol_callbacks()
+
+    # The key assertion: callback count should not have increased significantly
+    # Allow for a small number of legitimate callbacks but ensure no major leak
+    assert (
+        final_count - initial_count <= 5
+    ), f"ProtocolCallback leak detected: initial={initial_count}, final={final_count}, leaked={final_count - initial_count}"
diff --git a/tests/utils.py b/tests/utils.py
index 154a25f8d..6a78eefaf 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -12,63 +12,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import re
-from typing import List, Tuple, cast
+from typing import Optional, TypeVar
 
-from playwright._impl._api_types import Error
-from playwright._impl._element_handle import ElementHandle
-from playwright._impl._frame import Frame
-from playwright._impl._page import Page
-from playwright._impl._selectors import Selectors
+TARGET_CLOSED_ERROR_MESSAGE = "Target page, context or browser has been closed"
 
+MustType = TypeVar("MustType")
 
-class Utils:
-    async def attach_frame(self, page: Page, frame_id: str, url: str):
-        handle = await page.evaluate_handle(
-            """async ({ frame_id, url }) => {
-                const frame = document.createElement('iframe');
-                frame.src = url;
-                frame.id = frame_id;
-                document.body.appendChild(frame);
-                await new Promise(x => frame.onload = x);
-                return frame;
-            }""",
-            {"frame_id": frame_id, "url": url},
-        )
-        return await cast(ElementHandle, handle.as_element()).content_frame()
 
-    async def detach_frame(self, page: Page, frame_id: str):
-        await page.evaluate(
-            "frame_id => document.getElementById(frame_id).remove()", frame_id
-        )
+def must(value: Optional[MustType]) -> MustType:
+    assert value
+    return value
 
-    def dump_frames(self, frame: Frame, indentation: str = "") -> List[str]:
-        indentation = indentation or ""
-        description = re.sub(r":\d+/", ":<PORT>/", frame.url)
-        if frame.name:
-            description += " (" + frame.name + ")"
-        result = [indentation + description]
-        sorted_frames = sorted(
-            frame.child_frames, key=lambda frame: frame.url + frame.name
-        )
-        for child in sorted_frames:
-            result = result + utils.dump_frames(child, "    " + indentation)
-        return result
 
-    async def verify_viewport(self, page: Page, width: int, height: int):
-        assert cast(Tuple[int, int], page.viewport_size())[0] == width
-        assert cast(Tuple[int, int], page.viewport_size())[1] == height
-        assert await page.evaluate("window.innerWidth") == width
-        assert await page.evaluate("window.innerHeight") == height
-
-    async def register_selector_engine(
-        self, selectors: Selectors, *args, **kwargs
-    ) -> None:
-        try:
-            await selectors.register(*args, **kwargs)
-        except Error as exc:
-            if "has been already registered" not in exc.message:
-                raise exc
-
-
-utils = Utils()
+def chromium_version_less_than(a: str, b: str) -> bool:
+    left = list(map(int, a.split(".")))
+    right = list(map(int, b.split(".")))
+    for i in range(4):
+        if left[i] > right[i]:
+            return False
+        if left[i] < right[i]:
+            return True
+    return False
diff --git a/utils/docker/.gitignore b/utils/docker/.gitignore
new file mode 100644
index 000000000..8803f25de
--- /dev/null
+++ b/utils/docker/.gitignore
@@ -0,0 +1 @@
+oras/
diff --git a/utils/docker/Dockerfile.jammy b/utils/docker/Dockerfile.jammy
new file mode 100644
index 000000000..7692ad7c5
--- /dev/null
+++ b/utils/docker/Dockerfile.jammy
@@ -0,0 +1,61 @@
+FROM ubuntu:jammy
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG TZ=America/Los_Angeles
+ARG DOCKER_IMAGE_NAME_TEMPLATE="mcr.microsoft.com/playwright/python:v%version%-jammy"
+
+ENV LANG=C.UTF-8
+ENV LC_ALL=C.UTF-8
+
+# === INSTALL Python ===
+
+RUN apt-get update && \
+    # Install Python
+    apt-get install -y python3 python3-distutils curl && \
+    update-alternatives --install /usr/bin/python python /usr/bin/python3 1 && \
+    curl -sSL https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \
+    python get-pip.py && \
+    rm get-pip.py && \
+    # Feature-parity with node.js base images.
+    apt-get install -y --no-install-recommends git openssh-client gpg && \
+    # clean apt cache
+    rm -rf /var/lib/apt/lists/* && \
+    # Create the pwuser
+    adduser pwuser
+
+# === BAKE BROWSERS INTO IMAGE ===
+
+ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
+
+# 1. Add tip-of-tree Playwright package to install its browsers.
+#    The package should be built beforehand from tip-of-tree Playwright.
+COPY ./dist/*-manylinux*.whl /tmp/
+
+# 2. Bake in browsers & deps.
+#    Browsers will be downloaded in `/ms-playwright`.
+#    Note: make sure to set 777 to the registry so that any user can access
+#    registry.
+RUN mkdir /ms-playwright && \
+    mkdir /ms-playwright-agent && \
+    cd /ms-playwright-agent && \
+    pip install virtualenv && \
+    virtualenv venv && \
+    . venv/bin/activate && \
+    # if its amd64 then install the manylinux1_x86_64 pip package
+    if [ "$(uname -m)" = "x86_64" ]; then pip install /tmp/*manylinux1_x86_64*.whl; fi && \
+    # if its arm64 then install the manylinux1_aarch64 pip package
+    if [ "$(uname -m)" = "aarch64" ]; then pip install /tmp/*manylinux_2_17_aarch64*.whl; fi && \
+    playwright mark-docker-image "${DOCKER_IMAGE_NAME_TEMPLATE}" && \
+    playwright install --with-deps && rm -rf /var/lib/apt/lists/* && \
+    # Workaround for https://github.com/microsoft/playwright/issues/27313
+    # While the gstreamer plugin load process can be in-process, it ended up throwing
+    # an error that it can't have libsoup2 and libsoup3 in the same process because
+    # libgstwebrtc is linked against libsoup2. So we just remove the plugin.
+    if [ "$(uname -m)" = "aarch64" ]; then \
+        rm /usr/lib/aarch64-linux-gnu/gstreamer-1.0/libgstwebrtc.so; \
+    else \
+        rm /usr/lib/x86_64-linux-gnu/gstreamer-1.0/libgstwebrtc.so; \
+    fi && \
+    rm /tmp/*.whl && \
+    rm -rf /ms-playwright-agent && \
+    chmod -R 777 /ms-playwright
diff --git a/utils/docker/Dockerfile.noble b/utils/docker/Dockerfile.noble
new file mode 100644
index 000000000..2458236a3
--- /dev/null
+++ b/utils/docker/Dockerfile.noble
@@ -0,0 +1,55 @@
+FROM ubuntu:noble
+
+ARG DEBIAN_FRONTEND=noninteractive
+ARG TZ=America/Los_Angeles
+ARG DOCKER_IMAGE_NAME_TEMPLATE="mcr.microsoft.com/playwright/python:v%version%-noble"
+
+ENV LANG=C.UTF-8
+ENV LC_ALL=C.UTF-8
+
+# === INSTALL Python ===
+
+RUN apt-get update && \
+    # Install Python
+    apt-get install -y python3 curl && \
+    # Align with upstream Python image and don't be externally managed:
+    # https://github.com/docker-library/python/issues/948
+    rm /usr/lib/python3.12/EXTERNALLY-MANAGED && \
+    update-alternatives --install /usr/bin/python python /usr/bin/python3 1 && \
+    curl -sSL https://bootstrap.pypa.io/get-pip.py -o get-pip.py && \
+    python get-pip.py && \
+    rm get-pip.py && \
+    # Feature-parity with node.js base images.
+    apt-get install -y --no-install-recommends git openssh-client gpg && \
+    # clean apt cache
+    rm -rf /var/lib/apt/lists/* && \
+    # Create the pwuser
+    adduser pwuser
+
+# === BAKE BROWSERS INTO IMAGE ===
+
+ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
+
+# 1. Add tip-of-tree Playwright package to install its browsers.
+#    The package should be built beforehand from tip-of-tree Playwright.
+COPY ./dist/*-manylinux*.whl /tmp/
+
+# 2. Bake in browsers & deps.
+#    Browsers will be downloaded in `/ms-playwright`.
+#    Note: make sure to set 777 to the registry so that any user can access
+#    registry.
+RUN mkdir /ms-playwright && \
+    mkdir /ms-playwright-agent && \
+    cd /ms-playwright-agent && \
+    pip install virtualenv && \
+    virtualenv venv && \
+    . venv/bin/activate && \
+    # if its amd64 then install the manylinux1_x86_64 pip package
+    if [ "$(uname -m)" = "x86_64" ]; then pip install /tmp/*manylinux1_x86_64*.whl; fi && \
+    # if its arm64 then install the manylinux1_aarch64 pip package
+    if [ "$(uname -m)" = "aarch64" ]; then pip install /tmp/*manylinux_2_17_aarch64*.whl; fi && \
+    playwright mark-docker-image "${DOCKER_IMAGE_NAME_TEMPLATE}" && \
+    playwright install --with-deps && rm -rf /var/lib/apt/lists/* && \
+    rm /tmp/*.whl && \
+    rm -rf /ms-playwright-agent && \
+    chmod -R 777 /ms-playwright
diff --git a/utils/docker/build.sh b/utils/docker/build.sh
new file mode 100755
index 000000000..98b0b0233
--- /dev/null
+++ b/utils/docker/build.sh
@@ -0,0 +1,43 @@
+#!/bin/bash
+set -e
+set +x
+
+if [[ ($1 == '--help') || ($1 == '-h') || ($1 == '') || ($2 == '') ]]; then
+  echo "usage: $(basename $0) {--arm64,--amd64} {jammy,noble} playwright:localbuild-noble"
+  echo
+  echo "Build Playwright docker image and tag it as 'playwright:localbuild-noble'."
+  echo "Once image is built, you can run it with"
+  echo ""
+  echo "  docker run --rm -it playwright:localbuild-noble /bin/bash"
+  echo ""
+  echo "NOTE: this requires on Playwright PIP dependencies to be installed"
+  echo ""
+  exit 0
+fi
+
+function cleanup() {
+  rm -rf "dist/"
+}
+
+trap "cleanup; cd $(pwd -P)" EXIT
+cd "$(dirname "$0")"
+
+pushd ../../
+for wheel in $(python setup.py --list-wheels); do
+  PLAYWRIGHT_TARGET_WHEEL=$wheel python -m build --wheel
+done
+popd
+mkdir dist/
+cp ../../dist/*-manylinux*.whl dist/
+
+PLATFORM=""
+if [[ "$1" == "--arm64" ]]; then
+  PLATFORM="linux/arm64";
+elif [[ "$1" == "--amd64" ]]; then
+  PLATFORM="linux/amd64"
+else
+  echo "ERROR: unknown platform specifier - $1. Only --arm64 or --amd64 is supported"
+  exit 1
+fi
+
+docker build --platform "${PLATFORM}" -t "$3" -f "Dockerfile.$2" .
diff --git a/utils/docker/publish_docker.sh b/utils/docker/publish_docker.sh
new file mode 100755
index 000000000..3af48306b
--- /dev/null
+++ b/utils/docker/publish_docker.sh
@@ -0,0 +1,124 @@
+#!/bin/bash
+
+set -e
+set +x
+
+trap "cd $(pwd -P)" EXIT
+cd "$(dirname "$0")"
+
+MCR_IMAGE_NAME="playwright/python"
+PW_VERSION=$(python -c "from playwright._repo_version import version;print(version)")
+
+RELEASE_CHANNEL="$1"
+if [[ "${RELEASE_CHANNEL}" == "stable" ]]; then
+  if [[ "${PW_VERSION}" == *post* ]]; then
+    echo "ERROR: cannot publish stable docker with Playwright version '${PW_VERSION}'"
+    exit 1
+  fi
+else
+  echo "ERROR: unknown release channel - ${RELEASE_CHANNEL}"
+  echo "Must be either 'stable' or 'canary'"
+  exit 1
+fi
+
+# Ubuntu 22.04
+JAMMY_TAGS=(
+  "v${PW_VERSION}-jammy"
+)
+
+# Ubuntu 24.04
+NOBLE_TAGS=(
+  "v${PW_VERSION}"
+  "v${PW_VERSION}-noble"
+)
+
+tag_and_push() {
+  local source="$1"
+  local target="$2"
+  echo "-- tagging: $target"
+  docker tag $source $target
+  docker push $target
+  attach_eol_manifest $target
+}
+
+attach_eol_manifest() {
+  local image="$1"
+  local today=$(date -u +'%Y-%m-%d')
+  install_oras_if_needed
+  # oras is re-using Docker credentials, so we don't need to login.
+  # Following the advice in https://portal.microsofticm.com/imp/v3/incidents/incident/476783820/summary
+  ./oras/oras attach --artifact-type application/vnd.microsoft.artifact.lifecycle --annotation "vnd.microsoft.artifact.lifecycle.end-of-life.date=$today" $image
+}
+
+install_oras_if_needed() {
+  if [[ -x oras/oras ]]; then
+    return
+  fi
+  local version="1.1.0"
+  curl -sLO "https://github.com/oras-project/oras/releases/download/v${version}/oras_${version}_linux_amd64.tar.gz"
+  mkdir -p oras
+  tar -zxf oras_${version}_linux_amd64.tar.gz -C oras
+  rm oras_${version}_linux_amd64.tar.gz
+}
+
+publish_docker_images_with_arch_suffix() {
+  local FLAVOR="$1"
+  local TAGS=()
+  if [[ "$FLAVOR" == "jammy" ]]; then
+    TAGS=("${JAMMY_TAGS[@]}")
+  elif [[ "$FLAVOR" == "noble" ]]; then
+    TAGS=("${NOBLE_TAGS[@]}")
+  else
+    echo "ERROR: unknown flavor - $FLAVOR. Must be either 'jammy', or 'noble'"
+    exit 1
+  fi
+  local ARCH="$2"
+  if [[ "$ARCH" != "amd64" && "$ARCH" != "arm64" ]]; then
+    echo "ERROR: unknown arch - $ARCH. Must be either 'amd64' or 'arm64'"
+    exit 1
+  fi
+  # Prune docker images to avoid platform conflicts
+  docker system prune -fa
+  ./build.sh "--${ARCH}" "${FLAVOR}" "${MCR_IMAGE_NAME}:localbuild"
+
+  for ((i = 0; i < ${#TAGS[@]}; i++)) do
+    local TAG="${TAGS[$i]}"
+    tag_and_push "${MCR_IMAGE_NAME}:localbuild" "playwright.azurecr.io/public/${MCR_IMAGE_NAME}:${TAG}-${ARCH}"
+  done
+}
+
+publish_docker_manifest () {
+  local FLAVOR="$1"
+  local TAGS=()
+  if [[ "$FLAVOR" == "jammy" ]]; then
+    TAGS=("${JAMMY_TAGS[@]}")
+  elif [[ "$FLAVOR" == "noble" ]]; then
+    TAGS=("${NOBLE_TAGS[@]}")
+  else
+    echo "ERROR: unknown flavor - $FLAVOR. Must be either 'jammy', or 'noble'"
+    exit 1
+  fi
+
+  for ((i = 0; i < ${#TAGS[@]}; i++)) do
+    local TAG="${TAGS[$i]}"
+    local BASE_IMAGE_TAG="playwright.azurecr.io/public/${MCR_IMAGE_NAME}:${TAG}"
+    local IMAGE_NAMES=""
+    if [[ "$2" == "arm64" || "$2" == "amd64" ]]; then
+        IMAGE_NAMES="${IMAGE_NAMES} ${BASE_IMAGE_TAG}-$2"
+    fi
+    if [[ "$3" == "arm64" || "$3" == "amd64" ]]; then
+        IMAGE_NAMES="${IMAGE_NAMES} ${BASE_IMAGE_TAG}-$3"
+    fi
+    docker manifest create "${BASE_IMAGE_TAG}" $IMAGE_NAMES
+    docker manifest push "${BASE_IMAGE_TAG}"
+  done
+}
+
+# Jammy
+publish_docker_images_with_arch_suffix jammy amd64
+publish_docker_images_with_arch_suffix jammy arm64
+publish_docker_manifest jammy amd64 arm64
+
+publish_docker_images_with_arch_suffix noble amd64
+publish_docker_images_with_arch_suffix noble arm64
+publish_docker_manifest noble amd64 arm64
diff --git a/utils/linting/check_file_header.py b/utils/linting/check_file_header.py
new file mode 100755
index 000000000..5ccf79d5f
--- /dev/null
+++ b/utils/linting/check_file_header.py
@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+# 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 sys
+from pathlib import Path
+from typing import List
+
+LICENSE_HEADER = """
+# 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.
+""".strip()
+
+
+def file_has_license(file_path: str) -> None:
+    path = Path(file_path)
+    if not path.name.endswith(".py"):
+        return
+    if not path.exists():
+        raise Exception(f"File {file_path} does not exist")
+    content = path.read_text(encoding="utf-8")
+    if content.strip() == "":
+        return
+    if content.startswith("#!"):
+        # flake8: noqa: E203
+        content = content[content.find("\n") + 1 :]
+    if not content.startswith(LICENSE_HEADER):
+        raise Exception(f"File {file_path} does not have license header")
+
+
+def main() -> None:
+    errors: List[str] = []
+
+    for file_path in sys.argv[1:]:
+        try:
+            file_has_license(file_path)
+        except Exception as e:
+            errors.append(str(e))
+
+    if errors:
+        print("Missing license header in files:")
+        for error in errors:
+            print("  -", error)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()